maskweaver 0.9.4 → 0.9.6

package/dist/weave/orchestrator.d.ts

@@ -1,98 +1,29 @@
-/**
- * Weave Orchestrator
- *
- * Automatically selects expert masks based on task context.
- * This is the "brain" that decides which persona to wear for each task.
- */
 import type { WeaveTask, WeaveConfig, AgentTier, TaskComplexity, PhaseExecutionPlan } from './types.js';
 import type { WeavePhase } from './types.js';
 export type TaskType = 'architecture' | 'testing' | 'frontend' | 'backend' | 'performance' | 'database' | 'ml' | 'devops' | 'general';
 export declare class WeaveOrchestrator {
     private config;
     constructor(config?: Partial<WeaveConfig>);
-    /**
-     * Detect the type of task from its description.
-     */
     detectTaskType(taskDescription: string): TaskType;
-    /**
-     * Select the best mask for a task.
-     * Considers: task type, user preferences, and context.
-     */
     selectMaskForTask(task: WeaveTask): string | null;
-    /**
-     * Select mask for error analysis/debugging.
-     * Performance/system errors → Linus, Architecture errors → Martin, etc.
-     */
     selectMaskForError(errorMessage: string): string;
-    /**
-     * Suggest mask rotation for stuck situations.
-     * If current mask isn't solving the problem, try a different perspective.
-     */
     suggestAlternativeMask(currentMask: string, taskType: TaskType): string;
-    /**
-     * Get configuration.
-     */
     getConfig(): WeaveConfig;
-    /**
-     * Complexity signal patterns.
-     * Each pattern adds to a complexity score when matched.
-     */
     private static readonly COMPLEXITY_SIGNALS;
-    /**
-     * Simple task patterns — if matched, override to simple.
-     */
     private static readonly SIMPLE_PATTERNS;
-    /**
-     * Assess complexity of a task based on its name/description.
-     * Returns: simple (score 0), standard (score 1-2), complex (score 3+)
-     */
     assessComplexity(taskDescription: string): TaskComplexity;
-    /**
-     * Select the appropriate agent tier based on task complexity.
-     *
-     * Strategy:
-     * - simple   -> dummy-flash   (fast, cheap: file renames, formatting, config)
-     * - standard -> dummy-human   (balanced: component implementation, API endpoints)
-     * - complex  -> dummy-premium (powerful: architecture, debugging, multi-step reasoning)
-     */
     selectAgentTier(complexity: TaskComplexity): AgentTier;
-    /** Map TaskType to ModelCapability tags for pool-based selection */
     private static readonly TASK_TYPE_CAPABILITIES;
-    /** Map complexity to ModelTier for pool queries */
     private static readonly COMPLEXITY_TIER_MAP;
-    /**
-     * Select the best available agent from the model pool.
-     * This considers:
-     * 1. Task complexity -> preferred tier
-     * 2. Task type -> required capabilities
-     * 3. Model availability -> concurrency limits
-     * 4. Cost awareness -> prefer cheaper when possible
-     *
-     * Returns the agent name to use (e.g., "dummy-gemini-flash")
-     * or falls back to the legacy tier name (e.g., "dummy-flash")
-     */
     selectAgentFromPool(task: WeaveTask): {
         agentName: string;
         tier: AgentTier;
         poolManaged: boolean;
     };
-    /**
-     * Release a model back to the pool after task completion.
-     */
     releaseAgent(agentName: string): boolean;
-    /**
-     * Generate execution plan for a phase.
-     * Analyzes each task and determines:
-     * 1. Which expert mask to use
-     * 2. Which agent tier (model) to delegate to
-     * 3. Any relevant troubleshooting hints from global knowledge
-     */
     generateExecutionPlan(phase: WeavePhase, options?: {
         projectType?: string;
     }): Promise<PhaseExecutionPlan>;
-    /**
-     * Update configuration.
-     */
     updateConfig(updates: Partial<WeaveConfig>): void;
 }
 export declare function getOrchestrator(config?: Partial<WeaveConfig>): WeaveOrchestrator;

package/dist/weave/orchestrator.js

@@ -1,9 +1,3 @@
-/**
- * Weave Orchestrator
- *
- * Automatically selects expert masks based on task context.
- * This is the "brain" that decides which persona to wear for each task.
- */
 import { searchTroubleshooting } from './knowledge/global.js';
 import { getModelRegistry } from '../shared/model-registry.js';
 const TASK_PATTERNS = {
@@ -47,7 +41,6 @@ const TASK_PATTERNS = {
     ],
     general: []
 };
-// Default mask recommendations per task type
 const DEFAULT_MASKS = {
     architecture: 'martin-fowler',
     testing: 'kent-beck',
@@ -57,11 +50,8 @@ const DEFAULT_MASKS = {
     database: 'martin-fowler',
     ml: 'andrew-ng',
     devops: 'linus-torvalds',
-    general: 'kent-beck' // Good all-rounder with TDD focus
+    general: 'kent-beck'
 };
-// ============================================================================
-// Orchestrator Class
-// ============================================================================
 export class WeaveOrchestrator {
     config;
     constructor(config = {}) {
@@ -73,11 +63,7 @@ export class WeaveOrchestrator {
             maskPreferences: config.maskPreferences ?? {},
         };
     }
-    /**
-     * Detect the type of task from its description.
-     */
     detectTaskType(taskDescription) {
-        // Check each pattern set
         for (const [type, patterns] of Object.entries(TASK_PATTERNS)) {
             if (type === 'general')
                 continue;
@@ -89,54 +75,35 @@ export class WeaveOrchestrator {
         }
         return 'general';
     }
-    /**
-     * Select the best mask for a task.
-     * Considers: task type, user preferences, and context.
-     */
     selectMaskForTask(task) {
         if (!this.config.autoSelectMasks) {
             return null;
         }
         const taskType = this.detectTaskType(task.name);
-        // Check user preferences first
         if (this.config.maskPreferences) {
             const preferred = this.config.maskPreferences[taskType];
             if (preferred) {
                 return preferred;
             }
         }
-        // Fall back to defaults
         return DEFAULT_MASKS[taskType] || null;
     }
-    /**
-     * Select mask for error analysis/debugging.
-     * Performance/system errors → Linus, Architecture errors → Martin, etc.
-     */
     selectMaskForError(errorMessage) {
         const lower = errorMessage.toLowerCase();
-        // Performance/memory issues → Linus
         if (/memory|leak|performance|slow|timeout|race|concurrent/.test(lower)) {
             return 'linus-torvalds';
         }
-        // Type/structure issues → Martin (architecture perspective)
         if (/type|interface|abstract|pattern|coupling|dependency/.test(lower)) {
             return 'martin-fowler';
         }
-        // Test failures → Kent
         if (/test|assert|expect|mock|spec|coverage/.test(lower)) {
             return 'kent-beck';
         }
-        // React/frontend issues → Dan
         if (/react|component|hook|state|render|jsx|tsx/.test(lower)) {
             return 'dan-abramov';
         }
-        // Default to Kent for methodical debugging
         return 'kent-beck';
     }
-    /**
-     * Suggest mask rotation for stuck situations.
-     * If current mask isn't solving the problem, try a different perspective.
-     */
     suggestAlternativeMask(currentMask, taskType) {
         const alternatives = {
             'kent-beck': ['martin-fowler', 'linus-torvalds'],
@@ -148,21 +115,10 @@ export class WeaveOrchestrator {
         const options = alternatives[currentMask] || ['kent-beck'];
         return options[0];
     }
-    /**
-     * Get configuration.
-     */
     getConfig() {
         return { ...this.config };
     }
-    // ========================================================================
-    // Task Complexity Assessment
-    // ========================================================================
-    /**
-     * Complexity signal patterns.
-     * Each pattern adds to a complexity score when matched.
-     */
     static COMPLEXITY_SIGNALS = [
-        // High complexity signals (+2)
         { pattern: /architect/i, weight: 2 },
         { pattern: /refactor/i, weight: 2 },
         { pattern: /design pattern/i, weight: 2 },
@@ -174,7 +130,6 @@ export class WeaveOrchestrator {
         { pattern: /debug|troubleshoot|diagnos/i, weight: 2 },
         { pattern: /security|encrypt|vulnerab/i, weight: 2 },
         { pattern: /algorithm|data structure/i, weight: 2 },
-        // Medium complexity signals (+1)
         { pattern: /component/i, weight: 1 },
         { pattern: /api|endpoint|route/i, weight: 1 },
         { pattern: /test|spec/i, weight: 1 },
@@ -184,9 +139,6 @@ export class WeaveOrchestrator {
         { pattern: /validation/i, weight: 1 },
         { pattern: /integrate/i, weight: 1 },
     ];
-    /**
-     * Simple task patterns — if matched, override to simple.
-     */
     static SIMPLE_PATTERNS = [
         /rename|renames/i,
         /import|imports/i,
@@ -199,12 +151,7 @@ export class WeaveOrchestrator {
         /add export/i,
         /fix lint/i,
     ];
-    /**
-     * Assess complexity of a task based on its name/description.
-     * Returns: simple (score 0), standard (score 1-2), complex (score 3+)
-     */
     assessComplexity(taskDescription) {
-        // Check for explicit simple patterns first
         for (const pattern of WeaveOrchestrator.SIMPLE_PATTERNS) {
             if (pattern.test(taskDescription)) {
                 return 'simple';
@@ -222,14 +169,6 @@ export class WeaveOrchestrator {
             return 'standard';
         return 'simple';
     }
-    /**
-     * Select the appropriate agent tier based on task complexity.
-     *
-     * Strategy:
-     * - simple   -> dummy-flash   (fast, cheap: file renames, formatting, config)
-     * - standard -> dummy-human   (balanced: component implementation, API endpoints)
-     * - complex  -> dummy-premium (powerful: architecture, debugging, multi-step reasoning)
-     */
     selectAgentTier(complexity) {
         switch (complexity) {
             case 'simple':
@@ -240,10 +179,6 @@ export class WeaveOrchestrator {
                 return 'dummy-premium';
         }
     }
-    // ========================================================================
-    // Model Pool Integration
-    // ========================================================================
-    /** Map TaskType to ModelCapability tags for pool-based selection */
     static TASK_TYPE_CAPABILITIES = {
         architecture: ['architecture', 'reasoning', 'complex-coding'],
         testing: ['testing', 'coding'],
@@ -255,23 +190,11 @@ export class WeaveOrchestrator {
         devops: ['devops', 'file-ops'],
         general: ['coding'],
     };
-    /** Map complexity to ModelTier for pool queries */
     static COMPLEXITY_TIER_MAP = {
         simple: 'flash',
         standard: 'human',
         complex: 'premium',
     };
-    /**
-     * Select the best available agent from the model pool.
-     * This considers:
-     * 1. Task complexity -> preferred tier
-     * 2. Task type -> required capabilities
-     * 3. Model availability -> concurrency limits
-     * 4. Cost awareness -> prefer cheaper when possible
-     *
-     * Returns the agent name to use (e.g., "dummy-gemini-flash")
-     * or falls back to the legacy tier name (e.g., "dummy-flash")
-     */
     selectAgentFromPool(task) {
         const complexity = this.assessComplexity(task.name);
         const defaultTier = this.selectAgentTier(complexity);
@@ -279,7 +202,6 @@ export class WeaveOrchestrator {
         try {
             const registry = getModelRegistry();
             const pool = registry.getPool();
-            // If no pool configured, fall back to legacy
             if (pool.length === 0) {
                 return { agentName: defaultTier, tier: defaultTier, poolManaged: false };
             }
@@ -297,21 +219,15 @@ export class WeaveOrchestrator {
                     poolManaged: true,
                 };
             }
-            // Pool exhausted -- fall back to legacy tier name
             return { agentName: defaultTier, tier: defaultTier, poolManaged: false };
         }
         catch {
-            // Registry not initialized -- fall back to legacy
             return { agentName: defaultTier, tier: defaultTier, poolManaged: false };
         }
     }
-    /**
-     * Release a model back to the pool after task completion.
-     */
     releaseAgent(agentName) {
         try {
             const registry = getModelRegistry();
-            // Agent name format: "dummy-{modelId}"
             const modelId = agentName.replace(/^dummy-/, '');
             return registry.release(modelId);
         }
@@ -319,20 +235,12 @@ export class WeaveOrchestrator {
             return false;
         }
     }
-    /**
-     * Generate execution plan for a phase.
-     * Analyzes each task and determines:
-     * 1. Which expert mask to use
-     * 2. Which agent tier (model) to delegate to
-     * 3. Any relevant troubleshooting hints from global knowledge
-     */
     async generateExecutionPlan(phase, options) {
         const taskPlans = [];
         for (const task of phase.tasks) {
             const mask = this.selectMaskForTask(task);
             const complexity = this.assessComplexity(task.name);
             const agentTier = this.selectAgentTier(complexity);
-            // Pre-fetch troubleshooting hints for known error patterns
             let troubleshootingHints = [];
             if (this.config.globalKnowledge) {
                 try {
@@ -342,7 +250,6 @@ export class WeaveOrchestrator {
                         .map(s => s.entry.solution.slice(0, 200));
                 }
                 catch {
-                    // Knowledge search is best-effort
                 }
             }
             taskPlans.push({
@@ -353,7 +260,6 @@ export class WeaveOrchestrator {
                 troubleshootingHints,
             });
         }
-        // Generate human-readable summary
         const tierCounts = { flash: 0, human: 0, premium: 0 };
         for (const p of taskPlans) {
             if (p.agentTier === 'dummy-flash')
@@ -380,16 +286,10 @@ export class WeaveOrchestrator {
             summary: summaryParts.join('\n'),
         };
     }
-    /**
-     * Update configuration.
-     */
     updateConfig(updates) {
         this.config = { ...this.config, ...updates };
     }
 }
-// ============================================================================
-// Singleton Instance
-// ============================================================================
 let orchestratorInstance = null;
 export function getOrchestrator(config) {
     if (!orchestratorInstance) {

package/dist/weave/phase-manager.d.ts

@@ -1,9 +1,3 @@
-/**
- * Phase Manager
- *
- * Manages phase lifecycle and persistence.
- * Integrates with Maskweaver's context module for file tracking.
- */
 import type { WeavePhase, WeavePlan, PhaseStatus } from './types.js';
 import type { RepairResult } from './yaml-repair.js';
 export declare class PhaseManager {
@@ -11,33 +5,13 @@ export declare class PhaseManager {
     private plan;
     private _recoveryMessages;
     constructor(basePath?: string);
-    /**
-     * Get recovery messages from last load operation.
-     * UI can display these to inform the user about auto-repairs.
-     */
     getRecoveryMessages(): string[];
-    /**
-     * Load existing plan or return null.
-     * Supports multi-plan architecture (state.yaml → plans/) with legacy PLAN.yaml fallback.
-     * Auto-repairs corrupted YAML files when possible.
-     */
     loadPlan(): Promise<WeavePlan | null>;
-    /**
-     * Save plan to disk using safe file I/O (atomic writes with backup).
-     * If state.yaml exists (new mode): save to plans/{planName}.yaml and update state.yaml.
-     * Otherwise (legacy mode): save to PLAN.yaml.
-     */
     savePlan(plan: WeavePlan): Promise<void>;
-    /**
-     * Repair all plan files. Returns repair report.
-     */
     repairPlans(): Promise<{
         results: RepairResult[];
         summary: string;
     }>;
-    /**
-     * Create a new plan.
-     */
     createPlan(input: {
         planName?: string;
         projectName: string;
@@ -50,59 +24,21 @@ export declare class PhaseManager {
         shardTotal?: number;
         nextPlanName?: string;
     }): Promise<WeavePlan>;
-    /**
-     * Get a specific phase.
-     */
     getPhase(phaseId: string): WeavePhase | null;
-    /**
-     * Update phase status.
-     */
     updatePhaseStatus(phaseId: string, status: PhaseStatus, additionalData?: Partial<WeavePhase>): Promise<WeavePhase | null>;
-    /**
-     * Add tasks to a phase.
-     */
     addTasks(phaseId: string, tasks: Omit<WeavePhase['tasks'][0], 'status' | 'retryCount'>[]): Promise<void>;
-    /**
-     * Update task status.
-     */
     updateTaskStatus(phaseId: string, taskId: string, status: 'pending' | 'in_progress' | 'passed' | 'failed', additionalData?: Partial<WeavePhase['tasks'][0]>): Promise<void>;
-    /**
-     * Mark all tasks in a phase as passed.
-     * Useful when the phase is approved after full verification.
-     */
     markAllTasksPassed(phaseId: string): Promise<void>;
-    /**
-     * Get next pending phase (respecting dependencies).
-     */
     getNextPhase(): WeavePhase | null;
-    /**
-     * Get plan statistics.
-     */
     getStats(): {
         totalPhases: number;
         completedPhases: number;
         inProgressPhases: number;
         progress: number;
     };
-    /**
-     * Convert project name to a filesystem-safe plan file name.
-     */
     private toPlanFileName;
-    /**
-     * Load all plans from the plans/ directory.
-     * Returns empty array in legacy mode or if no plans exist.
-     * Auto-repairs corrupted plans when possible.
-     */
     loadAllPlans(): Promise<WeavePlan[]>;
-    /**
-     * Get the active plan name from state.yaml.
-     * Returns null in legacy mode or if state.yaml doesn't exist.
-     */
     getActivePlanName(): Promise<string | null>;
-    /**
-     * Load and return state.yaml content.
-     * Returns null if state.yaml doesn't exist (legacy mode).
-     */
     loadState(): Promise<{
         active_plan?: string;
     } | null>;