maskweaver 0.9.4 → 0.9.6

package/dist/weave/stages/intake.js

@@ -1,16 +1,7 @@
-/**
- * Weave Intake Stage
- *
- * Document analysis and question generation.
- * Uses Maskweaver memory for semantic search of past similar projects.
- */
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { analyzeEnvironment } from '../environment/index.js';
 import { readMapResult } from './map.js';
-// ============================================================================
-// Document Discovery
-// ============================================================================
 const DOC_EXTENSIONS = ['.md', '.txt', '.yaml', '.yml', '.json'];
 const INDEX_FILES = ['index.md', 'README.md', 'readme.md'];
 function discoverDocuments(basePath) {
@@ -19,7 +10,6 @@ function discoverDocuments(basePath) {
         if (!fs.existsSync(dir))
             return;
         const entries = fs.readdirSync(dir, { withFileTypes: true });
-        // Prioritize index files
         for (const indexFile of INDEX_FILES) {
             const indexPath = path.join(dir, indexFile);
             if (fs.existsSync(indexPath)) {
@@ -42,19 +32,13 @@ function discoverDocuments(basePath) {
     walk(basePath);
     return docs;
 }
-// ============================================================================
-// Document Analysis
-// ============================================================================
 function analyzeDocument(filePath) {
     const content = fs.readFileSync(filePath, 'utf-8');
     const fileName = path.basename(filePath);
-    // Extract title (first H1 or filename)
     const titleMatch = content.match(/^#\s+(.+)$/m);
     const title = titleMatch ? titleMatch[1] : fileName.replace(/\.[^.]+$/, '');
-    // Extract sections (H2 headers)
     const sectionMatches = content.match(/^##\s+(.+)$/gm) || [];
     const sections = sectionMatches.map(s => s.replace(/^##\s+/, ''));
-    // Extract key points (bullet points under important headers)
     const keyPoints = [];
     const bulletMatches = content.match(/^[-*]\s+(.+)$/gm) || [];
     for (const bullet of bulletMatches.slice(0, 10)) {
@@ -67,9 +51,6 @@ function analyzeDocument(filePath) {
         keyPoints,
     };
 }
-// ============================================================================
-// Feature Extraction
-// ============================================================================
 const FEATURE_PATTERNS = [
     /(?:기능|feature|functionality)[:：]\s*(.+)/gi,
     /(?:할 수 있다|can|should|must)\s+(.+)/gi,
@@ -78,13 +59,11 @@ const FEATURE_PATTERNS = [
 function extractFeatures(documents) {
     const features = new Set();
     for (const doc of documents) {
-        // From key points
         for (const point of doc.keyPoints) {
             if (point.length > 10 && point.length < 100) {
                 features.add(point);
             }
         }
-        // From sections
         for (const section of doc.sections) {
             if (section.length > 5 && section.length < 50) {
                 features.add(section);
@@ -93,9 +72,6 @@ function extractFeatures(documents) {
     }
     return Array.from(features).slice(0, 20);
 }
-// ============================================================================
-// Technical Requirements Detection
-// ============================================================================
 const TECH_PATTERNS = {
     frontend: [
         /react/i, /vue/i, /angular/i, /svelte/i, /next\.?js/i,
@@ -129,13 +105,9 @@ function detectTechnicalRequirements(documents) {
     }
     return result;
 }
-// ============================================================================
-// Question Generation
-// ============================================================================
 function generateQuestions(features, techReqs) {
     const questions = [];
     let qId = 1;
-    // If no frontend detected, ask
     if (!techReqs.frontend || techReqs.frontend.length === 0) {
         questions.push({
             id: `Q${qId++}`,
@@ -145,7 +117,6 @@ function generateQuestions(features, techReqs) {
             required: true,
         });
     }
-    // If no database detected, ask
     if (!techReqs.database || techReqs.database.length === 0) {
         questions.push({
             id: `Q${qId++}`,
@@ -155,7 +126,6 @@ function generateQuestions(features, techReqs) {
             required: true,
         });
     }
-    // Priority question
     if (features.length > 3) {
         questions.push({
             id: `Q${qId++}`,
@@ -167,36 +137,23 @@ function generateQuestions(features, techReqs) {
     }
     return questions;
 }
-/**
- * Search memory for similar past projects based on features.
- * Uses hybrid search (vector + text) from memory module.
- */
 async function searchSimilarProjects(features, techStack) {
     const results = [];
     try {
-        // Dynamic import to avoid circular dependencies
         const memoryModule = await import('../../memory/index.js');
-        // Build query from features and tech stack
         const query = [...features.slice(0, 5), ...techStack].join(' ');
-        // Get database instance (returns null if not initialized)
         const db = memoryModule.tryGetDatabase();
         if (!db) {
             console.log('[Intake] Memory database not initialized, skipping similar project search');
             return results;
         }
-        // Create a text-only provider for simple search
-        // ProviderConfig uses 'type' not 'provider'
         const provider = memoryModule.createProvider({
             type: 'text-only',
         });
-        // Use hybridSearch or fall back to text search
         let searchResults = [];
         if (provider) {
-            // Try semantic search if provider available
-            // embed() takes string[] and returns Embedding[] (number[][])
             const embeddingResult = await provider.embed([query]);
-            const embedding = embeddingResult[0]; // Get first (only) embedding
-            // hybridSearch takes (query, queryEmbedding, options)
+            const embedding = embeddingResult[0];
             searchResults = memoryModule.hybridSearch(query, embedding, {
                 limit: 5,
                 minScore: 0.3,
@@ -204,23 +161,19 @@ async function searchSimilarProjects(features, techStack) {
         }
         else {
             console.log('[Intake] Provider not available, using text search only');
-            // Fall back to text-only search
             const textResults = db.searchByText(query, 5);
             searchResults = textResults.map((r) => ({
                 chunk: r.chunk,
-                score: r.score || 0.5, // Default score for text matches
+                score: r.score || 0.5,
             }));
         }
-        // Process results to extract project insights
         for (const result of searchResults) {
             const { chunk, score } = result;
-            // Try to extract project name from path
             const pathParts = chunk.path.split(/[/\\]/);
             const projectName = pathParts.find((p) => !p.startsWith('.') &&
                 p !== 'memory' &&
                 p !== 'daily' &&
                 !p.endsWith('.md')) || 'Previous Project';
-            // Extract relevant features mentioned
             const relevantFeatures = features.filter(f => chunk.text.toLowerCase().includes(f.toLowerCase().slice(0, 10)));
             if (relevantFeatures.length > 0 || score > 0.5) {
                 results.push({
@@ -233,14 +186,10 @@ async function searchSimilarProjects(features, techStack) {
         }
     }
     catch (e) {
-        // Memory search is optional, don't fail intake
         console.log('[Intake] Similar project search failed:', e);
     }
     return results;
 }
-// ============================================================================
-// Map Integration — Structural Change Detection & Consent
-// ============================================================================
 export async function injectMapContext(map, features) {
     const structuralChanges = [];
     const consentPrompts = [];
@@ -347,49 +296,40 @@ export async function intake(options) {
     const extendedOptions = options;
     const skipEnvironmentAnalysis = extendedOptions.skipEnvironmentAnalysis ?? false;
     const warningsOnly = extendedOptions.warningsOnly ?? false;
-    // Resolve path
     const absolutePath = path.isAbsolute(docsPath)
         ? docsPath
         : path.join(process.cwd(), docsPath);
     if (!fs.existsSync(absolutePath)) {
         throw new Error(`Documents path not found: ${absolutePath}`);
     }
-    // Discover documents
     const docPaths = fs.statSync(absolutePath).isDirectory()
         ? discoverDocuments(absolutePath)
         : [absolutePath];
     if (docPaths.length === 0) {
         throw new Error(`No documents found in: ${absolutePath}`);
     }
-    // Analyze each document
     const documents = docPaths.map(analyzeDocument);
-    // Extract information
     const features = extractFeatures(documents);
     const technicalRequirements = detectTechnicalRequirements(documents);
     const questions = generateQuestions(features, technicalRequirements);
-    // Build tech stack array for memory search
     const techStack = [
         ...(technicalRequirements.frontend || []),
         ...(technicalRequirements.backend || []),
         ...(technicalRequirements.database || []),
     ];
-    // Search memory for similar past projects
     const similarProjectResults = await searchSimilarProjects(features, techStack);
     const similarProjects = similarProjectResults.map(r => `${r.projectName} (${(r.similarity * 100).toFixed(0)}% 유사): ${r.relevantFeatures.join(', ')}`);
-    // Proactive environment analysis
     let environment;
     if (!skipEnvironmentAnalysis) {
         try {
-            // Get the project directory (parent of docs path or current working directory)
             const projectPath = fs.statSync(absolutePath).isDirectory()
-                ? path.dirname(absolutePath) // Parent of docs folder
-                : path.dirname(absolutePath); // Same for single file
+                ? path.dirname(absolutePath)
+                : path.dirname(absolutePath);
             environment = await analyzeEnvironment({
                 projectPath: projectPath !== '.' ? projectPath : process.cwd(),
                 warningsOnly,
                 includeProjectHistory: true,
             });
-            // Log critical issues
             const criticalIssues = environment.issues.filter(i => i.severity === 'critical');
             if (criticalIssues.length > 0) {
                 console.log(`\n⚠️  [Intake] ${criticalIssues.length}개의 Critical 이슈가 감지되었습니다!`);
@@ -410,7 +350,7 @@ export async function intake(options) {
     return {
         documents,
         features,
-        domainTerms: [], // TODO: Extract domain-specific terminology
+        domainTerms: [],
         technicalRequirements,
         questions,
         similarProjects: similarProjects.length > 0 ? similarProjects : undefined,

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

@@ -3,7 +3,6 @@ export interface MapOptions {
     basePath?: string;
     onMessage?: (msg: string) => void;
     useGraphify?: boolean;
-    /** If true, runs graphify-windows skill for deep knowledge graph analysis */
     deep?: boolean;
 }
 export declare function analyzeCodebase(options: MapOptions): Promise<MapResult>;

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

@@ -3,7 +3,6 @@ export interface OpenSpecOutputOptions {
     basePath: string;
     changeId: string;
     plan: WeavePlan;
-    /** Overwrite existing files (default: false). */
     overwrite?: boolean;
 }
 export interface OpenSpecOutputResult {

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

@@ -1,24 +1,13 @@
-/**
- * Weave Plan Stage
- *
- * Create phase-based execution plan from analyzed requirements.
- * Generates testable MVPs per phase with clear completion criteria.
- */
 import type { WeavePhase, WeavePlan } from '../types.js';
 import type { IntakeResult } from './intake.js';
 export interface PlanOptions {
     intake: IntakeResult;
     projectName: string;
-    /** Optional stable identifier used for plan filename/state.yaml */
     planName?: string;
-    /** Base path for .opencode/weave (defaults to process.cwd()) */
     basePath?: string;
     userAnswers?: Record<string, string>;
-    /** Auto-split oversized plans into multiple shard plan files (default: true). */
     splitPlans?: boolean;
-    /** Max phases per shard plan when splitting (default: 3). */
     splitMaxPhases?: number;
-    /** Max estimated hours per shard plan when splitting (default: 10). */
     splitMaxHours?: number;
 }
 export interface PlanResult {

package/dist/weave/stages/plan.js

@@ -1,15 +1,6 @@
-/**
- * Weave Plan Stage
- *
- * Create phase-based execution plan from analyzed requirements.
- * Generates testable MVPs per phase with clear completion criteria.
- */
 import { getPhaseManager } from '../phase-manager.js';
 import { getEffectiveGdcConfig, runGdcMachineCommand, getGraphNodeIds, getGraphEdges, countGdcCheckIssues, } from '../gdc.js';
 import { generateOpenSpecArtifacts, ensureOpenSpecWorkspace } from './openspec.js';
-// ============================================================================
-// Phase Size Estimation
-// ============================================================================
 const PHASE_SIZE_GUIDE = {
     tooSmall: ['변수명 변경', '오타 수정'],
     justRight: ['UI 컴포넌트 하나', '저장 기능', 'API 엔드포인트 하나'],
@@ -126,14 +117,10 @@ function buildSplitSummary(rootPlanName, shards, totalHours) {
     lines.push('Next: approve current shard, then run craft. Next shard is auto-activated when current shard is completed.');
     return lines.join('\n');
 }
-// ============================================================================
-// Architecture Inference
-// ============================================================================
 function inferArchitecture(intake, userAnswers) {
     const arch = {
         notes: '아키텍처는 진행하면서 조정될 수 있습니다',
     };
-    // From detected requirements
     if (intake.technicalRequirements.frontend?.length) {
         arch.frontend = intake.technicalRequirements.frontend.join(' + ');
     }
@@ -143,7 +130,6 @@ function inferArchitecture(intake, userAnswers) {
     if (intake.technicalRequirements.database?.length) {
         arch.database = intake.technicalRequirements.database.join(' + ');
     }
-    // From user answers
     if (userAnswers) {
         for (const [key, value] of Object.entries(userAnswers)) {
             if (key.includes('프론트엔드') || key.includes('frontend')) {
@@ -154,39 +140,30 @@ function inferArchitecture(intake, userAnswers) {
             }
         }
     }
-    // Defaults
     if (!arch.frontend)
         arch.frontend = 'React + Vite';
     if (!arch.database)
         arch.database = 'LocalStorage (Phase 1-3)';
     return arch;
 }
-// ============================================================================
-// Phase Generation
-// ============================================================================
 function generatePhases(intake, userAnswers) {
     const phases = [];
     const features = intake.features;
-    // Determine priority order
     let prioritizedFeatures = [...features];
     if (userAnswers) {
         const priorityAnswer = Object.entries(userAnswers).find(([k]) => k.includes('우선순위') || k.includes('priority'));
         if (priorityAnswer) {
             const priority = priorityAnswer[1];
-            // Move priority feature to front
             prioritizedFeatures = [
                 priority,
                 ...features.filter(f => f !== priority)
             ];
         }
     }
-    // Generate phases from features
     let phaseNum = 1;
     for (const feature of prioritizedFeatures.slice(0, 8)) {
         const phaseId = `P${phaseNum}`;
-        // Create completion criteria
         const doneWhen = `유저가 ${feature.toLowerCase().replace(/[을를이가은는]/g, '')}할 수 있다`;
-        // Create checklist items
         const checklist = [
             `${feature} 관련 UI가 표시되는가?`,
             `기능이 정상 동작하는가?`,
@@ -198,7 +175,7 @@ function generatePhases(intake, userAnswers) {
             status: 'pending',
             doneWhen,
             checklist,
-            estimatedHours: 3, // Default estimate
+            estimatedHours: 3,
             dependsOn: phaseNum > 1 ? [`P${phaseNum - 1}`] : undefined,
         });
         phaseNum++;
@@ -388,14 +365,9 @@ function inferPhaseDependenciesFromGraph(phases, phaseNodeMap, edges) {
         };
     });
 }
-// ============================================================================
-// Main Plan Function
-// ============================================================================
 export async function plan(options) {
     const { intake, projectName, userAnswers, planName, basePath } = options;
-    // Infer architecture
     const architecture = inferArchitecture(intake, userAnswers);
-    // Generate phases
     let phases = generatePhases(intake, userAnswers);
     const gdcSignals = await collectGdcPlanningSignals(basePath, intake);
     const intakeNeedles = buildNeedlesFromIntake(intake);
@@ -412,20 +384,16 @@ export async function plan(options) {
                 : gdcNote;
         }
     }
-    // Create vision summary
     const vision = intake.features.length > 0
         ? `${projectName}: ${intake.features.slice(0, 3).join(', ')} 등의 기능을 제공하는 애플리케이션`
         : `${projectName} 애플리케이션`;
-    // Attach structural changes from intake
     const structuralChanges = intake.structuralChanges?.filter(sc => sc.agreed) || [];
-    // Calculate total estimated hours
     const estimatedTotalHours = phases.reduce((sum, p) => sum + (p.estimatedHours || 3), 0);
     const normalizedPlanName = normalizePlanName(planName || toKebabCase(projectName) || 'weave-plan');
     const splitConfig = resolveSplitConfig(options);
     const manager = getPhaseManager(basePath);
     if (shouldSplitPlan(phases, estimatedTotalHours, splitConfig)) {
         const groups = partitionPhases(phases, splitConfig);
-        // If partitioning still yields one group, keep the standard single-plan flow.
         if (groups.length > 1) {
             const createdShards = [];
             for (let i = 0; i < groups.length; i += 1) {
@@ -473,7 +441,6 @@ export async function plan(options) {
             if (!firstShard) {
                 throw new Error('Failed to create shard plans from oversized plan');
             }
-            // Set active shard to the first one for immediate execution.
             await manager.savePlan(firstShard.plan);
             return {
                 plan: firstShard.plan,
@@ -484,7 +451,6 @@ export async function plan(options) {
             };
         }
     }
-    // Standard single-plan flow
     const weavePlan = await manager.createPlan({
         planName: normalizedPlanName,
         projectName,
@@ -493,17 +459,14 @@ export async function plan(options) {
         phases,
         planRole: 'standalone',
     });
-    // Attach structural changes to plan
     if (structuralChanges.length > 0) {
         weavePlan.structuralChanges = structuralChanges;
         await manager.savePlan(weavePlan);
     }
-    // Attach map info if available
     if (intake.codebaseMapPath) {
         weavePlan.mapReportPath = intake.codebaseMapPath;
         weavePlan.mapGeneratedAt = new Date().toISOString();
     }
-    // vNext: Generate a baseline executable task list per phase
     for (const phase of weavePlan.phases) {
         const tasks = generateDefaultPhaseTasks(phase, {
             changeId: weavePlan.planName || normalizedPlanName,
@@ -514,7 +477,6 @@ export async function plan(options) {
             await manager.addTasks(phase.id, tasks);
         }
     }
-    // Generate OpenSpec artifacts
     try {
         const changeId = weavePlan.planName || normalizedPlanName;
         await ensureOpenSpecWorkspace(basePath || process.cwd());
@@ -527,9 +489,7 @@ export async function plan(options) {
         weavePlan.openspecDir = openspecResult.changeDir;
     }
     catch {
-        // OpenSpec generation is best-effort
     }
-    // Generate summary
     const summary = generatePlanSummary(weavePlan, estimatedTotalHours);
     return {
         plan: weavePlan,
@@ -540,7 +500,6 @@ export async function plan(options) {
     };
 }
 function generateDefaultPhaseTasks(phase, gdc) {
-    // Keep tasks small, specific, and runnable. Downstream craft can refine.
     const baseId = phase.id;
     const title = phase.name;
     const nodeIds = (gdc?.nodeIds || []).slice(0, 4);
@@ -602,9 +561,6 @@ function toKebabCase(input) {
         .replace(/[^a-z0-9]+/g, '-')
         .replace(/^-+|-+$/g, '');
 }
-// ============================================================================
-// Summary Generation
-// ============================================================================
 function generatePlanSummary(plan, totalHours) {
     const lines = [];
     lines.push(`## 📋 실행 계획서`);
@@ -661,24 +617,18 @@ function generatePlanSummary(plan, totalHours) {
     lines.push(`승인 후 \`/weave build\`로 자율 실행을 시작합니다.`);
     return lines.join('\n');
 }
-// ============================================================================
-// Plan Modification
-// ============================================================================
 export async function modifyPlan(modifications) {
     const manager = getPhaseManager();
     const plan = await manager.loadPlan();
     if (!plan) {
         throw new Error('No plan exists to modify');
     }
-    // Remove phases
     if (modifications.removePhases) {
         plan.phases = plan.phases.filter(p => !modifications.removePhases.includes(p.id));
     }
-    // Add phases
     if (modifications.addPhases) {
         plan.phases.push(...modifications.addPhases.map(p => ({ ...p, tasks: [] })));
     }
-    // Update phases
     if (modifications.updatePhases) {
         for (const { id, updates } of modifications.updatePhases) {
             const phase = plan.phases.find(p => p.id === id);
@@ -687,11 +637,9 @@ export async function modifyPlan(modifications) {
             }
         }
     }
-    // Update architecture
     if (modifications.updateArchitecture) {
         plan.architecture = { ...plan.architecture, ...modifications.updateArchitecture };
     }
-    // Save
     await manager.savePlan(plan);
     return plan;
 }

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

@@ -1,10 +1,3 @@
-/**
- * Weave Refine Stage
- *
- * Applies structured plan-note directives to an existing plan.
- * This enables an annotation cycle where humans edit notes and
- * the plan is updated mechanically before implementation.
- */
 import type { WeavePlan } from '../types.js';
 export interface RefinePlanResult {
     updatedPlan: WeavePlan;

package/dist/weave/stages/refine.js

@@ -1,10 +1,3 @@
-/**
- * Weave Refine Stage
- *
- * Applies structured plan-note directives to an existing plan.
- * This enables an annotation cycle where humans edit notes and
- * the plan is updated mechanically before implementation.
- */
 const STATUS_VALUES = new Set([
     'pending',
     'in_progress',

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

@@ -1,9 +1,3 @@
-/**
- * Weave Research Stage
- *
- * Produces a persistent research artifact before planning/implementation.
- * The report is intentionally markdown-first so humans can annotate and review.
- */
 import type { IntakeResult } from './intake.js';
 export interface ResearchOptions {
     docsPath: string;

package/dist/weave/stages/research.js

@@ -1,9 +1,3 @@
-/**
- * Weave Research Stage
- *
- * Produces a persistent research artifact before planning/implementation.
- * The report is intentionally markdown-first so humans can annotate and review.
- */
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { getEffectiveGdcConfig, runGdcMachineCommand, countGdcCheckIssues, getGraphNodeIds, getGraphEdges, getStatsNodeSummary, } from '../gdc.js';

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

@@ -1,13 +1,3 @@
-/**
- * Weave Spec Stage
- *
- * Converts intake analysis into a structured spec file.
- *
- * NOTE:
- * - This is intentionally conservative and heuristic-based.
- * - The goal is to produce a usable baseline spec (requirements + ACs)
- *   that can be refined later.
- */
 import type { IntakeResult } from './intake.js';
 export type RequirementCategory = 'functional' | 'constraint' | 'performance' | 'ux';
 export type RequirementPriority = 'must' | 'should' | 'could' | 'wont';
@@ -32,9 +22,7 @@ export interface WeaveSpec {
 export interface SpecOptions {
     intake: IntakeResult;
     projectName: string;
-    /** Spec name (kebab-case). Defaults to "weave-spec". */
     specName?: string;
-    /** Base path for .opencode/weave (defaults to process.cwd()). */
     basePath?: string;
 }
 export interface SpecResult {

package/dist/weave/stages/spec.js

@@ -1,20 +1,7 @@
-/**
- * Weave Spec Stage
- *
- * Converts intake analysis into a structured spec file.
- *
- * NOTE:
- * - This is intentionally conservative and heuristic-based.
- * - The goal is to produce a usable baseline spec (requirements + ACs)
- *   that can be refined later.
- */
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { stringify } from 'yaml';
 import { safeWriteFile } from '../yaml-repair.js';
-// ============================================================================
-// Helpers
-// ============================================================================
 const WEAVE_DIR = path.join('.opencode', 'weave');
 function toKebabCase(input) {
     return input
@@ -55,7 +42,6 @@ function defaultAcceptanceType(category) {
     }
 }
 function defaultScenario(desc, category) {
-    // Keep the scenario concise; downstream plan/craft can refine.
     switch (category) {
         case 'performance':
             return `${desc} (성능 기준을 만족한다)`;
@@ -95,9 +81,6 @@ function formatSpecSummary(spec, specPath) {
         `- 검증 기준: ${totalAC}개${typeLine ? ` (${typeLine})` : ''}`,
     ].join('\n');
 }
-// ============================================================================
-// Main
-// ============================================================================
 export async function spec(options) {
     const basePath = options.basePath || process.cwd();
     const specsDir = path.join(basePath, WEAVE_DIR, 'specs');