maskweaver 0.9.4 → 0.9.6

package/dist/weave/phase-manager.js

@@ -1,15 +1,6 @@
-/**
- * Phase Manager
- *
- * Manages phase lifecycle and persistence.
- * Integrates with Maskweaver's context module for file tracking.
- */
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { yamlEscapeString, safeWriteFile, safeReadYaml, validatePlanStructure, repairAllPlans } from './yaml-repair.js';
-// ============================================================================
-// Configuration
-// ============================================================================
 const WEAVE_DIR = '.opencode/weave';
 const PLAN_FILE = 'PLAN.yaml';
 const STATE_FILE = 'state.yaml';
@@ -38,9 +29,6 @@ function ensurePlansDir(basePath = process.cwd()) {
         fs.mkdirSync(dir, { recursive: true });
     }
 }
-// ============================================================================
-// YAML Serialization (Safe - with proper escaping)
-// ============================================================================
 function serializePlan(plan) {
     const lines = [];
     lines.push(`# Weave Plan - ${plan.projectName}`);
@@ -214,9 +202,6 @@ function serializePlan(plan) {
     }
     return lines.join('\n');
 }
-// ============================================================================
-// Phase Manager Class
-// ============================================================================
 export class PhaseManager {
     basePath;
     plan = null;
@@ -224,21 +209,11 @@ export class PhaseManager {
     constructor(basePath = process.cwd()) {
         this.basePath = basePath;
     }
-    /**
-     * Get recovery messages from last load operation.
-     * UI can display these to inform the user about auto-repairs.
-     */
     getRecoveryMessages() {
         return this._recoveryMessages;
     }
-    /**
-     * 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.
-     */
     async loadPlan() {
         this._recoveryMessages = [];
-        // 1. Try new multi-plan architecture: state.yaml → plans/{active_plan}.yaml
         const statePath = getStatePath(this.basePath);
         if (fs.existsSync(statePath)) {
             try {
@@ -271,7 +246,6 @@ export class PhaseManager {
                 console.error('[PhaseManager] Failed to load from state.yaml:', e);
             }
         }
-        // 2. Legacy fallback: PLAN.yaml
         const planPath = getPlanPath(this.basePath);
         if (!fs.existsSync(planPath)) {
             return null;
@@ -291,32 +265,21 @@ export class PhaseManager {
         }
         return 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.
-     */
     async savePlan(plan) {
         ensureWeaveDir(this.basePath);
         plan.updatedAt = new Date().toISOString();
         const content = serializePlan(plan);
         const statePath = getStatePath(this.basePath);
-        // vNext default: always use multi-plan mode. If state.yaml is missing,
-        // create it instead of falling back to legacy PLAN.yaml.
         if (!fs.existsSync(statePath)) {
             ensurePlansDir(this.basePath);
             const { stringify } = await import('yaml');
             safeWriteFile(statePath, stringify({ active_plan: null }));
         }
-        // Multi-plan mode: save to plans/ directory
         ensurePlansDir(this.basePath);
         const planName = this.toPlanFileName(plan.planName || plan.projectName);
-        // Persist normalized planName back onto the plan for stability
         plan.planName = planName;
         const planFilePath = path.join(getPlansDir(this.basePath), `${planName}.yaml`);
         safeWriteFile(planFilePath, content);
-        // Update state.yaml with active_plan while preserving additional keys.
-        // This avoids clobbering forward-compatible state fields.
         const { stringify } = await import('yaml');
         let stateData = {};
         try {
@@ -326,22 +289,15 @@ export class PhaseManager {
             }
         }
         catch {
-            // ignore state parse errors and overwrite with minimal state
         }
         stateData.active_plan = planName;
         const stateContent = stringify(stateData);
         safeWriteFile(statePath, stateContent);
         this.plan = plan;
     }
-    /**
-     * Repair all plan files. Returns repair report.
-     */
     async repairPlans() {
         return repairAllPlans(this.basePath);
     }
-    /**
-     * Create a new plan.
-     */
     async createPlan(input) {
         const now = new Date().toISOString();
         const plan = {
@@ -365,17 +321,11 @@ export class PhaseManager {
         await this.savePlan(plan);
         return plan;
     }
-    /**
-     * Get a specific phase.
-     */
     getPhase(phaseId) {
         if (!this.plan)
             return null;
         return this.plan.phases.find(p => p.id === phaseId) || null;
     }
-    /**
-     * Update phase status.
-     */
     async updatePhaseStatus(phaseId, status, additionalData) {
         if (!this.plan) {
             await this.loadPlan();
@@ -391,7 +341,6 @@ export class PhaseManager {
         }
         if (status === 'completed' && !phase.completedAt) {
             phase.completedAt = new Date().toISOString();
-            // Calculate actual hours if we have start time
             if (phase.startedAt) {
                 const start = new Date(phase.startedAt).getTime();
                 const end = new Date(phase.completedAt).getTime();
@@ -405,9 +354,6 @@ export class PhaseManager {
         await this.savePlan(this.plan);
         return phase;
     }
-    /**
-     * Add tasks to a phase.
-     */
     async addTasks(phaseId, tasks) {
         if (!this.plan) {
             await this.loadPlan();
@@ -425,9 +371,6 @@ export class PhaseManager {
         })));
         await this.savePlan(this.plan);
     }
-    /**
-     * Update task status.
-     */
     async updateTaskStatus(phaseId, taskId, status, additionalData) {
         if (!this.plan) {
             await this.loadPlan();
@@ -447,16 +390,11 @@ export class PhaseManager {
         if (additionalData) {
             Object.assign(task, additionalData);
         }
-        // Track masks used in phase
         if (task.maskUsed && !phase.masksUsed?.includes(task.maskUsed)) {
             phase.masksUsed = [...(phase.masksUsed || []), task.maskUsed];
         }
         await this.savePlan(this.plan);
     }
-    /**
-     * Mark all tasks in a phase as passed.
-     * Useful when the phase is approved after full verification.
-     */
     async markAllTasksPassed(phaseId) {
         if (!this.plan) {
             await this.loadPlan();
@@ -473,15 +411,11 @@ export class PhaseManager {
         }
         await this.savePlan(this.plan);
     }
-    /**
-     * Get next pending phase (respecting dependencies).
-     */
     getNextPhase() {
         if (!this.plan)
             return null;
         for (const phase of this.plan.phases) {
             if (phase.status === 'pending') {
-                // Check dependencies
                 if (phase.dependsOn && phase.dependsOn.length > 0) {
                     const allDepsCompleted = phase.dependsOn.every(depId => {
                         const dep = this.plan.phases.find(p => p.id === depId);
@@ -495,9 +429,6 @@ export class PhaseManager {
         }
         return null;
     }
-    /**
-     * Get plan statistics.
-     */
     getStats() {
         if (!this.plan) {
             return { totalPhases: 0, completedPhases: 0, inProgressPhases: 0, progress: 0 };
@@ -512,24 +443,15 @@ export class PhaseManager {
             progress: total > 0 ? Math.round((completed / total) * 100) : 0,
         };
     }
-    /**
-     * Convert project name to a filesystem-safe plan file name.
-     */
     toPlanFileName(projectName) {
         return projectName
             .toLowerCase()
             .replace(/[^a-z0-9]+/g, '-')
             .replace(/^-+|-+$/g, '') || 'unnamed';
     }
-    /**
-     * Load all plans from the plans/ directory.
-     * Returns empty array in legacy mode or if no plans exist.
-     * Auto-repairs corrupted plans when possible.
-     */
     async loadAllPlans() {
         const plansDir = getPlansDir(this.basePath);
         if (!fs.existsSync(plansDir)) {
-            // Legacy mode: try loading single PLAN.yaml
             const legacyPlan = await this.loadPlan();
             return legacyPlan ? [legacyPlan] : [];
         }
@@ -559,10 +481,6 @@ export class PhaseManager {
         }
         return plans;
     }
-    /**
-     * Get the active plan name from state.yaml.
-     * Returns null in legacy mode or if state.yaml doesn't exist.
-     */
     async getActivePlanName() {
         const statePath = getStatePath(this.basePath);
         if (!fs.existsSync(statePath)) {
@@ -571,10 +489,6 @@ export class PhaseManager {
         const result = await safeReadYaml(statePath);
         return result.data?.active_plan || null;
     }
-    /**
-     * Load and return state.yaml content.
-     * Returns null if state.yaml doesn't exist (legacy mode).
-     */
     async loadState() {
         const statePath = getStatePath(this.basePath);
         if (!fs.existsSync(statePath)) {
@@ -651,9 +565,6 @@ export class PhaseManager {
         };
     }
 }
-// ============================================================================
-// Convenience Functions
-// ============================================================================
 const managerCache = new Map();
 function normalizeBasePath(basePath) {
     return path.resolve(basePath || process.cwd());

package/dist/weave/security/secret-scan.d.ts

@@ -1,13 +1,3 @@
-/**
- * Secret Scan (Best-effort)
- *
- * This is a lightweight pre-commit guard. It is not a full DLP solution.
- *
- * Design goals:
- * - Scan only the files we are about to commit (staged list)
- * - Avoid dumping secrets in logs; always mask
- * - Keep false-positives low by using strong signatures
- */
 export type SecretKind = 'private_key' | 'aws_access_key_id' | 'github_token' | 'google_api_key' | 'openai_api_key' | 'slack_token' | 'generic_password';
 export type SecretSeverity = 'high' | 'medium';
 export interface SecretFinding {
@@ -21,17 +11,13 @@ export interface SecretFinding {
 export interface SecretScanConfig {
     version: 1;
     ignore?: {
-        /** Glob-like patterns (/, *, ** supported). */
         paths?: string[];
-        /** Ignore specific kinds entirely. */
         kinds?: SecretKind[];
     };
     allow?: {
-        /** Allowed matches by substring or `re:<regex>` */
         matches?: string[];
     };
     mode?: {
-        /** Which severities should block a commit. Default: ['high'] */
         blockSeverities?: SecretSeverity[];
     };
 }

package/dist/weave/security/secret-scan.js

@@ -1,17 +1,6 @@
-/**
- * Secret Scan (Best-effort)
- *
- * This is a lightweight pre-commit guard. It is not a full DLP solution.
- *
- * Design goals:
- * - Scan only the files we are about to commit (staged list)
- * - Avoid dumping secrets in logs; always mask
- * - Keep false-positives low by using strong signatures
- */
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { parse as parseYaml } from 'yaml';
-// Prefer strong signatures.
 const PATTERNS = [
     {
         kind: 'private_key',
@@ -43,8 +32,6 @@ const PATTERNS = [
         regex: /\bxox[baprs]-[A-Za-z0-9-]{10,}\b/,
         severity: 'high',
     },
-    // Lower confidence: password-like assignments.
-    // Keep strict: require key name + quotes.
     {
         kind: 'generic_password',
         regex: /\b(?:password|passwd|pwd)\b\s*[:=]\s*['"][^'"]{8,}['"]/i,
@@ -115,7 +102,6 @@ function matchesAnyGlob(globs, filePath) {
                 return true;
         }
         catch {
-            // ignore invalid glob
         }
     }
     return false;
@@ -184,13 +170,10 @@ function isProbablyBinary(buf) {
     let nonPrintable = 0;
     for (let i = 0; i < max; i++) {
         const b = buf[i];
-        // NUL
         if (b === 0)
             return true;
-        // allow tabs/newlines/cr
         if (b === 9 || b === 10 || b === 13)
             continue;
-        // printable ASCII range
         if (b >= 32 && b <= 126)
             continue;
         nonPrintable++;
@@ -205,7 +188,6 @@ function maskValue(value) {
 }
 function maskLine(line, match) {
     const masked = maskValue(match);
-    // Replace only first occurrence to keep context
     return line.replace(match, masked);
 }
 export function scanFilesForSecrets(options) {
@@ -263,7 +245,6 @@ export function scanFilesForSecrets(options) {
                     matchMasked: maskValue(rawMatch),
                     preview: maskLine(line, rawMatch).slice(0, 300),
                 });
-                // Only one finding per pattern per line.
                 break;
             }
         }

package/dist/weave/stages/build.js

@@ -144,7 +144,6 @@ function isPlanContractViolated(task, plan) {
         return false;
     if (!task.files || task.files.length === 0)
         return false;
-    // Violation: task touches files NOT covered by any agreed structural change
     const agreedFiles = new Set();
     for (const sc of agreedChanges) {
         for (const file of sc.affectedFiles)
@@ -222,11 +221,9 @@ function generateBrief(task, phase, plan, agentTier, mask) {
     lines.push(`---`);
     return lines.join('\n');
 }
-// Remove dead code: generateTaskBrief was duplicated inline above
 async function runVerification(basePath, task) {
     const checks = [];
     let allPassed = true;
-    // 1. TypeScript / build check
     try {
         const tsConfigPath = path.join(basePath, 'tsconfig.json');
         if (fs.existsSync(tsConfigPath)) {
@@ -249,7 +246,6 @@ async function runVerification(basePath, task) {
     catch {
         checks.push('⏭️ TypeScript check failed to run');
     }
-    // 2. GDC sync
     const gdc = getEffectiveGdcConfig(basePath);
     if (gdc.enabled) {
         try {
@@ -266,7 +262,6 @@ async function runVerification(basePath, task) {
             checks.push('⏭️ GDC sync error');
         }
     }
-    // 3. Task-specific verification
     if (task.verify) {
         for (const v of task.verify) {
             if (v.kind === 'checklist') {
@@ -349,7 +344,6 @@ export async function executeBuildLoop(options) {
     while (state.status === 'running') {
         const next = pickNextTask(plan, state, phaseFilter);
         if (!next) {
-            // Check if all tasks completed
             const allPassed = plan.phases.every(p => p.tasks.every(t => {
                 const ts = state.tasks.find(s => s.taskId === t.id && s.phaseId === p.id);
                 return ts?.status === 'passed' || t.status === 'passed';
@@ -368,7 +362,6 @@ export async function executeBuildLoop(options) {
         const { phase, task } = next;
         state.currentPhaseId = phase.id;
         state.currentTaskId = task.id;
-        // Check plan contract violation
         if (isPlanContractViolated(task, plan)) {
             state.status = 'blocked';
             state.escalationReason = `Task ${task.id} violates agreed plan contract (structural changes)`;
@@ -394,7 +387,6 @@ export async function executeBuildLoop(options) {
         }
         onEvent?.({ type: 'task_started', phaseId: phase.id, taskId: task.id });
         onMsg(`▶️ Running ${task.id} (${taskAgentTier})`);
-        // Execute task — generate brief for AI agent
         const taskStatus = state.tasks.find(t => t.taskId === task.id && t.phaseId === phase.id);
         const taskResult = await executeTask(task, phase, plan, orchestrator, basePath, onEvent);
         if (taskStatus && taskResult.instructions) {
@@ -404,10 +396,8 @@ export async function executeBuildLoop(options) {
             instructions.push(taskResult.instructions);
         }
         if (taskResult.success) {
-            // Verify
             const verification = await runVerification(basePath, task);
             if (verification.passed) {
-                // Mark task as passed
                 task.status = 'passed';
                 const ts = state.tasks.find(t => t.taskId === task.id && t.phaseId === phase.id);
                 if (ts) {
@@ -415,7 +405,6 @@ export async function executeBuildLoop(options) {
                     ts.completedAt = new Date().toISOString();
                     ts.commitHash = taskResult.commitHash;
                 }
-                // Update OpenSpec tasks
                 try {
                     if (plan.openspecDir) {
                         const changeId = plan.planName || 'main';
@@ -423,9 +412,7 @@ export async function executeBuildLoop(options) {
                     }
                 }
                 catch { }
-                // GDC sync per task
                 try {
-                    // Verification already ran GDC sync (no need to repeat)
                     await lightReMap(basePath);
                 }
                 catch { }
@@ -446,14 +433,12 @@ export async function executeBuildLoop(options) {
             iterationsWithoutProgress++;
             onMsg(`❌ ${task.id} failed: ${(taskResult.error || '').slice(0, 100)}`);
         }
-        // Check no-progress limit
         if (iterationsWithoutProgress >= maxIterationsWithoutProgress) {
             state.status = 'blocked';
             state.escalationReason = `No progress after ${iterationsWithoutProgress} consecutive task failures. Last: ${state.tasks.filter(t => t.status === 'failed').pop()?.taskId || 'unknown'}`;
             onMsg(`⛔ Blocked: ${state.escalationReason}`);
             break;
         }
-        // Save state after each task
         state.updatedAt = new Date().toISOString();
         await saveBuildState(basePath, state);
     }

package/dist/weave/stages/execute.d.ts

@@ -1,14 +1,3 @@
-/**
- * Weave Execute Stage
- *
- * Generates execution plans with automatic mask and agent tier selection.
- * Actual code generation/testing is performed by AI agents (dummy-flash/human/premium)
- * via the Task tool — this module handles:
- * - Phase validation and dependency checking
- * - Execution plan generation (mask + agent tier per task)
- * - Formatting the plan for the Mask Weaver to act upon
- * - AI-driven verification system integration
- */
 import type { WeavePhase, WeaveTask, WeaveEvent, PhaseExecutionPlan } from '../types.js';
 import { WeaveOrchestrator } from '../orchestrator.js';
 export interface ExecuteOptions {
@@ -16,7 +5,6 @@ export interface ExecuteOptions {
     onEvent?: (event: WeaveEvent) => void;
     projectType?: string;
     techStack?: string[];
-    /** Base path for .opencode/weave (defaults to process.cwd()) */
     basePath?: string;
 }
 export interface PrepareResult {
@@ -42,34 +30,9 @@ export interface TaskExecutionContext {
     projectType?: string;
     techStack?: string[];
 }
-/**
- * Prepare a phase for execution.
- *
- * This is the primary entry point for craft. It:
- * 1. Validates dependencies
- * 2. Marks the phase as in_progress
- * 3. Generates an execution plan (mask + agent tier per task)
- * 4. Returns the plan for the Mask Weaver to delegate via Task tool
- *
- * The actual code generation/testing is performed by AI agents
- * (dummy-flash, dummy-human, dummy-premium) — not by this function.
- */
 export declare function preparePhaseExecution(options: ExecuteOptions): Promise<PrepareResult>;
-/**
- * Format a PhaseExecutionPlan into markdown instructions
- * that the Mask Weaver can read and act upon.
- */
 export declare function formatExecutionPlan(plan: PhaseExecutionPlan): string;
-/**
- * @deprecated Use preparePhaseExecution() + formatExecutionPlan() instead.
- * Kept for backward compatibility.
- */
 export declare function execute(options: ExecuteOptions): Promise<ExecuteResult>;
-/**
- * Multi-layer verification that AI can perform automatically.
- * Each layer returns pass/fail with error details.
- * If any layer fails, the execute loop will retry.
- */
 export interface VerificationLayer {
     name: string;
     order: number;
@@ -91,13 +54,8 @@ export interface AIVerificationOptions {
     enableScreenshots?: boolean;
     enablePlaywright?: boolean;
     enableDevTools?: boolean;
-    /** Verification scope. quick: TypeCheck + UnitTests only. full: all available. */
     mode?: 'quick' | 'full';
 }
-/**
- * Run all verification layers in order.
- * Returns as soon as any layer fails.
- */
 export declare function runAIVerification(options: AIVerificationOptions): Promise<{
     passed: boolean;
     results: VerificationResult[];