@wundam/orchex 1.0.0-rc.2 → 1.0.0-rc.21

package/dist/intelligence/anti-pattern-detector.d.ts

@@ -1,117 +0,0 @@
-import type { StreamDefinitionInput } from '../types.js';
-/**
- * Anti-pattern detection severity levels
- */
-export type Severity = 'error' | 'warning' | 'info';
-/**
- * Detected anti-pattern issue
- */
-export interface AntiPatternIssue {
-    type: string;
-    severity: Severity;
-    message: string;
-    details?: string;
-    streamName: string;
-}
-/**
- * Analysis result for a stream definition
- */
-export interface StreamAnalysis {
-    streamName: string;
-    qualityScore: number;
-    issues: AntiPatternIssue[];
-    metrics: {
-        ownsCount: number;
-        readsCount: number;
-        directoriesAffected: number;
-        planConjunctions: number;
-        verifyCommands: number;
-        actionTypes: string[];
-        fileTypes: Set<string>;
-    };
-}
-/**
- * Batch analysis result for multiple streams
- */
-export interface BatchAnalysisResult {
-    streams: StreamAnalysis[];
-    overallScore: number;
-    totalIssues: {
-        errors: number;
-        warnings: number;
-        info: number;
-    };
-}
-/**
- * Configuration for anti-pattern detection thresholds
- */
-export interface DetectorConfig {
-    maxOwnsCount: number;
-    maxReadsCount: number;
-    maxDirectories: number;
-    maxPlanConjunctions: number;
-    warnOnMixedActions: boolean;
-    warnOnMixedFileTypes: boolean;
-    requireVerifyCommands: boolean;
-}
-/**
- * Anti-pattern detector for stream definitions
- */
-export declare class AntiPatternDetector {
-    private config;
-    constructor(config?: DetectorConfig);
-    /**
-     * Analyze a single stream definition for anti-patterns.
-     * Accepts StreamDefinitionInput (partial) or StreamDefinition (parsed).
-     */
-    analyzeStream(name: string, stream: StreamDefinitionInput): StreamAnalysis;
-    /**
-     * Analyze multiple stream definitions.
-     * Accepts StreamDefinitionInput (partial) or StreamDefinition (parsed).
-     */
-    analyzeStreams(streams: Record<string, StreamDefinitionInput>): BatchAnalysisResult;
-    /**
-     * Count unique directories affected by file paths
-     */
-    private countDirectories;
-    /**
-     * Count 'and' conjunctions in plan text
-     */
-    private countConjunctions;
-    /**
-     * Detect action types from plan text
-     */
-    private detectActionTypes;
-    /**
-     * Detect file types from paths
-     */
-    private detectFileTypes;
-    /**
-     * Check if stream has mixed structural and content actions
-     */
-    private hasMixedActions;
-    /**
-     * Check if stream creates tutorials without specific file ownership
-     */
-    private hasUnboundedTutorial;
-    /**
-     * Check if plan is too vague
-     */
-    private hasVaguePlan;
-    /**
-     * Calculate quality score (0-100) based on issues and metrics
-     */
-    private calculateQualityScore;
-    /**
-     * Calculate overall quality score for multiple streams
-     */
-    private calculateOverallScore;
-    /**
-     * Count issues by severity
-     */
-    private countIssuesBySeverity;
-}
-/**
- * Create a detector with default configuration
- */
-export declare function createDetector(config?: Partial<DetectorConfig>): AntiPatternDetector;

package/dist/intelligence/anti-pattern-detector.js

@@ -1,327 +0,0 @@
-const DEFAULT_CONFIG = {
-    maxOwnsCount: 4,
-    maxReadsCount: 4,
-    maxDirectories: 2,
-    maxPlanConjunctions: 4,
-    warnOnMixedActions: true,
-    warnOnMixedFileTypes: true,
-    requireVerifyCommands: true,
-};
-/**
- * Anti-pattern detector for stream definitions
- */
-export class AntiPatternDetector {
-    config;
-    constructor(config = DEFAULT_CONFIG) {
-        this.config = config;
-    }
-    /**
-     * Analyze a single stream definition for anti-patterns.
-     * Accepts StreamDefinitionInput (partial) or StreamDefinition (parsed).
-     */
-    analyzeStream(name, stream) {
-        const issues = [];
-        const owns = stream.owns || [];
-        const reads = stream.reads || [];
-        const plan = stream.plan || '';
-        const verify = stream.verify || [];
-        // Calculate metrics
-        const ownsCount = owns.length;
-        const readsCount = reads.length;
-        const directoriesAffected = this.countDirectories(owns);
-        const planConjunctions = this.countConjunctions(plan);
-        const verifyCommands = verify.length;
-        const actionTypes = this.detectActionTypes(plan);
-        const fileTypes = this.detectFileTypes([...owns, ...reads]);
-        const metrics = {
-            ownsCount,
-            readsCount,
-            directoriesAffected,
-            planConjunctions,
-            verifyCommands,
-            actionTypes,
-            fileTypes,
-        };
-        // Check for high owns count
-        if (ownsCount > this.config.maxOwnsCount && directoriesAffected > this.config.maxDirectories) {
-            issues.push({
-                type: 'high_owns_complexity',
-                severity: 'error',
-                message: `Stream owns ${ownsCount} files across ${directoriesAffected} directories`,
-                details: `Consider splitting into smaller streams. Threshold: ${this.config.maxOwnsCount} files across ${this.config.maxDirectories} directories`,
-                streamName: name,
-            });
-        }
-        else if (ownsCount > this.config.maxOwnsCount) {
-            issues.push({
-                type: 'high_owns_count',
-                severity: 'warning',
-                message: `Stream owns ${ownsCount} files (threshold: ${this.config.maxOwnsCount})`,
-                details: 'Consider splitting into smaller, more focused streams',
-                streamName: name,
-            });
-        }
-        // Check for high reads count
-        if (readsCount > this.config.maxReadsCount) {
-            issues.push({
-                type: 'high_reads_count',
-                severity: 'warning',
-                message: `Stream reads ${readsCount} files (threshold: ${this.config.maxReadsCount})`,
-                details: 'Too many dependencies may indicate unclear scope or context bloat',
-                streamName: name,
-            });
-        }
-        // Check for compound plans
-        if (planConjunctions > this.config.maxPlanConjunctions) {
-            issues.push({
-                type: 'compound_plan',
-                severity: 'warning',
-                message: `Plan contains ${planConjunctions} 'and' conjunctions (threshold: ${this.config.maxPlanConjunctions})`,
-                details: 'Complex plans with multiple actions should be split into separate streams',
-                streamName: name,
-            });
-        }
-        // Check for mixed structure/content actions
-        if (this.config.warnOnMixedActions && this.hasMixedActions(actionTypes)) {
-            issues.push({
-                type: 'mixed_actions',
-                severity: 'warning',
-                message: 'Stream mixes structural changes with content changes',
-                details: `Detected actions: ${actionTypes.join(', ')}. Consider separating setup/structure from implementation`,
-                streamName: name,
-            });
-        }
-        // Check for unbounded tutorials
-        if (this.hasUnboundedTutorial(plan, owns)) {
-            issues.push({
-                type: 'unbounded_tutorial',
-                severity: 'error',
-                message: 'Stream appears to create tutorial/documentation without specific file ownership',
-                details: 'Tutorial or documentation streams must specify exact files in owns[]',
-                streamName: name,
-            });
-        }
-        // Check for mixed file types
-        if (this.config.warnOnMixedFileTypes && fileTypes.size > 3) {
-            issues.push({
-                type: 'mixed_file_types',
-                severity: 'info',
-                message: `Stream touches ${fileTypes.size} different file types`,
-                details: `File types: ${Array.from(fileTypes).join(', ')}. Consider organizing by concern`,
-                streamName: name,
-            });
-        }
-        // Check for missing verify commands
-        if (this.config.requireVerifyCommands && verifyCommands === 0 && ownsCount > 0) {
-            issues.push({
-                type: 'no_verify',
-                severity: 'warning',
-                message: 'Stream has no verify commands',
-                details: 'Add verify commands to ensure implementation correctness',
-                streamName: name,
-            });
-        }
-        // Check for empty plan
-        if (!plan || plan.trim().length === 0) {
-            issues.push({
-                type: 'empty_plan',
-                severity: 'error',
-                message: 'Stream has no plan description',
-                details: 'Every stream must have a clear plan describing what it does',
-                streamName: name,
-            });
-        }
-        // Check for vague plans
-        if (this.hasVaguePlan(plan)) {
-            issues.push({
-                type: 'vague_plan',
-                severity: 'info',
-                message: 'Plan may be too vague or generic',
-                details: 'Use specific, actionable language describing exact changes',
-                streamName: name,
-            });
-        }
-        const qualityScore = this.calculateQualityScore(issues, metrics);
-        return {
-            streamName: name,
-            qualityScore,
-            issues,
-            metrics,
-        };
-    }
-    /**
-     * Analyze multiple stream definitions.
-     * Accepts StreamDefinitionInput (partial) or StreamDefinition (parsed).
-     */
-    analyzeStreams(streams) {
-        const streamAnalyses = [];
-        for (const [name, stream] of Object.entries(streams)) {
-            streamAnalyses.push(this.analyzeStream(name, stream));
-        }
-        const totalIssues = this.countIssuesBySeverity(streamAnalyses);
-        const overallScore = this.calculateOverallScore(streamAnalyses);
-        return {
-            streams: streamAnalyses,
-            overallScore,
-            totalIssues,
-        };
-    }
-    /**
-     * Count unique directories affected by file paths
-     */
-    countDirectories(files) {
-        const dirs = new Set();
-        for (const file of files) {
-            const dir = file.substring(0, file.lastIndexOf('/'));
-            if (dir) {
-                dirs.add(dir);
-            }
-            else {
-                dirs.add('.');
-            }
-        }
-        return dirs.size;
-    }
-    /**
-     * Count 'and' conjunctions in plan text
-     */
-    countConjunctions(plan) {
-        const normalized = plan.toLowerCase();
-        const matches = normalized.match(/\band\b/g);
-        return matches ? matches.length : 0;
-    }
-    /**
-     * Detect action types from plan text
-     */
-    detectActionTypes(plan) {
-        const normalized = plan.toLowerCase();
-        const actions = [];
-        const patterns = [
-            { type: 'create', pattern: /\b(create|add|implement|build)\b/ },
-            { type: 'update', pattern: /\b(update|modify|change|edit|refactor)\b/ },
-            { type: 'delete', pattern: /\b(delete|remove)\b/ },
-            { type: 'configure', pattern: /\b(configure|setup|install)\b/ },
-            { type: 'test', pattern: /\b(test|verify)\b/ },
-            { type: 'document', pattern: /\b(document|write|tutorial)\b/ },
-        ];
-        for (const { type, pattern } of patterns) {
-            if (pattern.test(normalized)) {
-                actions.push(type);
-            }
-        }
-        return actions;
-    }
-    /**
-     * Detect file types from paths
-     */
-    detectFileTypes(files) {
-        const types = new Set();
-        for (const file of files) {
-            const ext = file.substring(file.lastIndexOf('.') + 1).toLowerCase();
-            if (ext && ext !== file) {
-                types.add(ext);
-            }
-        }
-        return types;
-    }
-    /**
-     * Check if stream has mixed structural and content actions
-     */
-    hasMixedActions(actionTypes) {
-        const structural = ['create', 'delete', 'configure'];
-        const content = ['update', 'document'];
-        const hasStructural = actionTypes.some(a => structural.includes(a));
-        const hasContent = actionTypes.some(a => content.includes(a));
-        return hasStructural && hasContent;
-    }
-    /**
-     * Check if stream creates tutorials without specific file ownership
-     */
-    hasUnboundedTutorial(plan, owns) {
-        const normalized = plan.toLowerCase();
-        const isTutorial = /\b(tutorial|guide|documentation|example)\b/.test(normalized);
-        return isTutorial && owns.length === 0;
-    }
-    /**
-     * Check if plan is too vague
-     */
-    hasVaguePlan(plan) {
-        const normalized = plan.toLowerCase();
-        const vagueWords = ['various', 'some', 'multiple', 'general', 'misc', 'other', 'stuff', 'things'];
-        for (const word of vagueWords) {
-            if (normalized.includes(word)) {
-                return true;
-            }
-        }
-        // Check if plan is too short
-        return plan.trim().split(/\s+/).length < 5;
-    }
-    /**
-     * Calculate quality score (0-100) based on issues and metrics
-     */
-    calculateQualityScore(issues, metrics) {
-        let score = 100;
-        // Deduct points for issues
-        for (const issue of issues) {
-            switch (issue.severity) {
-                case 'error':
-                    score -= 20;
-                    break;
-                case 'warning':
-                    score -= 10;
-                    break;
-                case 'info':
-                    score -= 5;
-                    break;
-            }
-        }
-        // Bonus for good practices
-        if (metrics.verifyCommands > 0) {
-            score += 5;
-        }
-        if (metrics.ownsCount > 0 && metrics.ownsCount <= 3) {
-            score += 5;
-        }
-        if (metrics.planConjunctions === 0) {
-            score += 5;
-        }
-        return Math.max(0, Math.min(100, score));
-    }
-    /**
-     * Calculate overall quality score for multiple streams
-     */
-    calculateOverallScore(analyses) {
-        if (analyses.length === 0)
-            return 0;
-        const sum = analyses.reduce((acc, a) => acc + a.qualityScore, 0);
-        return Math.round(sum / analyses.length);
-    }
-    /**
-     * Count issues by severity
-     */
-    countIssuesBySeverity(analyses) {
-        const counts = { errors: 0, warnings: 0, info: 0 };
-        for (const analysis of analyses) {
-            for (const issue of analysis.issues) {
-                switch (issue.severity) {
-                    case 'error':
-                        counts.errors++;
-                        break;
-                    case 'warning':
-                        counts.warnings++;
-                        break;
-                    case 'info':
-                        counts.info++;
-                        break;
-                }
-            }
-        }
-        return counts;
-    }
-}
-/**
- * Create a detector with default configuration
- */
-export function createDetector(config) {
-    return new AntiPatternDetector({ ...DEFAULT_CONFIG, ...config });
-}

package/dist/intelligence/budget-enforcer.d.ts

@@ -1,119 +0,0 @@
-/**
- * Context budget enforcement for Orchex Learn.
- * Implements soft/hard limit checking with provider-aware context limits.
- */
-import type { ContextBudget, EnforcementLevel, BudgetViolationType } from '../types.js';
-/**
- * Provider-specific context window limits (in tokens).
- * These represent the maximum input context size for each provider's models.
- */
-export declare const PROVIDER_CONTEXT_LIMITS: Record<string, number>;
-/**
- * Model-specific context limits (overrides provider defaults).
- */
-export declare const MODEL_CONTEXT_LIMITS: Record<string, number>;
-/** Default soft limit as percentage of provider limit */
-export declare const DEFAULT_SOFT_LIMIT_RATIO = 0.7;
-/** Default hard limit as percentage of provider limit */
-export declare const DEFAULT_HARD_LIMIT_RATIO = 0.9;
-/** Default warning threshold (start warning at 80% of soft limit) */
-export declare const DEFAULT_WARNING_THRESHOLD = 0.8;
-/**
- * Configuration for budget checking.
- */
-export interface BudgetConfig {
-    /** Enforcement level: warn, soft, or hard */
-    enforcementLevel: EnforcementLevel;
-    /** Soft limit in tokens */
-    softLimitTokens: number;
-    /** Hard limit in tokens */
-    hardLimitTokens: number;
-    /** Warning threshold (0-1) */
-    warningThreshold: number;
-    /** Provider name */
-    provider: string;
-    /** Model name (optional, for more specific limits) */
-    model?: string;
-}
-/**
- * Result of checking context against budget.
- */
-export interface BudgetCheckResult {
-    /** Whether execution is allowed (considering enforcement level) */
-    allowed: boolean;
-    /** Type of violation (none, soft, hard) */
-    violationType: BudgetViolationType;
-    /** Estimated tokens for this context */
-    estimatedTokens: number;
-    /** The limit that was checked against */
-    budgetLimit: number;
-    /** Utilization ratio (0-1) */
-    utilizationRatio: number;
-    /** Warning message if applicable */
-    warning?: string;
-    /** Suggestion for reducing context size */
-    suggestion?: string;
-    /** Provider context limit for reference */
-    providerLimit: number;
-}
-/**
- * Get the context limit for a provider, optionally with model-specific override.
- */
-export declare function getProviderLimit(provider: string, model?: string): number;
-/**
- * Create a budget config from manifest/stream settings and provider info.
- */
-export declare function createBudgetConfig(budget: ContextBudget | undefined, provider: string, model?: string): BudgetConfig;
-/**
- * Generate a suggestion for reducing context size.
- */
-export declare function getSuggestion(violationType: BudgetViolationType, estimatedTokens: number, limit: number): string;
-/**
- * Check estimated context size against budget limits.
- *
- * @param estimatedTokens - Estimated context tokens
- * @param config - Budget configuration
- * @returns Check result with violation status and suggestions
- */
-export declare function checkBudget(estimatedTokens: number, config: BudgetConfig): BudgetCheckResult;
-/**
- * Analyze multiple streams for budget issues before execution.
- * Useful for validating at init time.
- */
-export interface StreamBudgetAnalysis {
-    streamId: string;
-    estimatedTokens: number;
-    check: BudgetCheckResult;
-}
-export interface BudgetAnalysisResult {
-    /** Total estimated tokens across all streams */
-    totalEstimatedTokens: number;
-    /** Streams that exceed soft limit */
-    streamsAtRisk: string[];
-    /** Streams that exceed hard limit */
-    streamsTooLarge: string[];
-    /** Whether any hard violations exist */
-    hasHardViolations: boolean;
-    /** Whether any soft violations exist */
-    hasSoftViolations: boolean;
-    /** Individual stream analyses */
-    analyses: StreamBudgetAnalysis[];
-    /** Warning messages */
-    warnings: string[];
-}
-/**
- * Analyze budget for multiple streams.
- *
- * @param streams - Map of stream ID to estimated tokens
- * @param config - Budget configuration
- * @returns Analysis result with warnings and violation details
- */
-export declare function analyzeStreamBudgets(streams: Map<string, number>, config: BudgetConfig): BudgetAnalysisResult;
-/**
- * Custom error for budget exceeded scenarios.
- */
-export declare class ContextBudgetExceededError extends Error {
-    readonly checkResult: BudgetCheckResult;
-    readonly streamId?: string | undefined;
-    constructor(checkResult: BudgetCheckResult, streamId?: string | undefined);
-}