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

package/dist/intelligence/plan-parser.js

@@ -1,498 +0,0 @@
-/**
- * Markdown plan document parser.
- * Extracts structure from planning documents for stream generation.
- */
-import { createLogger } from '../logging.js';
-const logger = createLogger('plan-parser');
-/**
- * Strip code blocks from text so file references inside code examples
- * (e.g., import paths with .js extensions) aren't treated as real file refs.
- */
-function stripCodeBlocks(text) {
-    return text.replace(/^```[\s\S]*?^```/gm, '');
-}
-/**
- * Extract file references from text.
- * Matches patterns like: `src/foo.ts`, "src/bar.js", src/baz.ts
- *
- * Code blocks are stripped first to avoid extracting import paths
- * (e.g., `from './foo.js'`) as real file references.
- *
- * Post-processing: `.js` files are dropped when a corresponding `.ts` exists,
- * since TypeScript projects use .js in imports but .ts as source files.
- */
-export function extractFileReferences(text) {
-    // Strip code blocks to avoid matching import paths as file references
-    const proseOnly = stripCodeBlocks(text);
-    const patterns = [
-        // Backtick-quoted paths
-        /`([^`]+\.(ts|js|tsx|jsx|md|sql|json|yaml|yml))`/g,
-        // Double-quoted paths
-        /"([^"]+\.(ts|js|tsx|jsx|md|sql|json|yaml|yml))"/g,
-        // Square bracket paths (markdown links)
-        /\[([^\]]+\.(ts|js|tsx|jsx|md|sql|json|yaml|yml))\]/g,
-        // Unquoted src/ paths
-        /\b(src\/[^\s,)]+\.(ts|js|tsx|jsx))/g,
-        // Unquoted tests/ paths
-        /\b(tests?\/[^\s,)]+\.(ts|js|tsx|jsx))/g,
-        // Unquoted docs/ paths
-        /\b(docs\/[^\s,)]+\.md)/g,
-    ];
-    const refs = new Set();
-    for (const pattern of patterns) {
-        // Reset regex state
-        pattern.lastIndex = 0;
-        let match;
-        while ((match = pattern.exec(proseOnly)) !== null) {
-            // Clean up the path
-            const filePath = match[1].trim();
-            if (filePath && !filePath.includes(' ')) {
-                refs.add(filePath);
-            }
-        }
-    }
-    // Drop .js files when a corresponding .ts exists (TypeScript ESM convention)
-    const result = [...refs];
-    return result.filter(ref => {
-        if (ref.endsWith('.js')) {
-            const tsEquivalent = ref.replace(/\.js$/, '.ts');
-            if (refs.has(tsEquivalent))
-                return false;
-        }
-        if (ref.endsWith('.jsx')) {
-            const tsxEquivalent = ref.replace(/\.jsx$/, '.tsx');
-            if (refs.has(tsxEquivalent))
-                return false;
-        }
-        return true;
-    });
-}
-/**
- * Extract explicit dependency mentions from text.
- * Matches patterns like: "depends on X", "requires Y", "after Z"
- */
-export function extractExplicitDeps(text) {
-    const patterns = [
-        /depends?\s+on\s+[`"]?([^`",.]+)[`"]?/gi,
-        /requires?\s+[`"]?([^`",.]+)[`"]?/gi,
-        /after\s+[`"]?([^`",.]+)[`"]?\s+(?:is\s+)?(?:complete|done|finished)/gi,
-        /\bdeps?:\s*\[([^\]]+)\]/gi,
-    ];
-    const deps = new Set();
-    for (const pattern of patterns) {
-        // Reset regex state
-        pattern.lastIndex = 0;
-        let match;
-        while ((match = pattern.exec(text)) !== null) {
-            // Handle array format: deps: [a, b, c]
-            if (pattern.source.includes('deps')) {
-                const items = match[1].split(',').map(s => s.trim().replace(/[`"']/g, ''));
-                for (const item of items) {
-                    if (item && item.length > 2 && item.length < 50) {
-                        deps.add(item);
-                    }
-                }
-            }
-            else {
-                // Clean up the match - remove quotes and trailing "is" (from "X is complete" pattern)
-                const dep = match[1].trim().replace(/\s+is$/i, '').replace(/[`"]/g, '');
-                if (dep && dep.length > 2 && dep.length < 50) {
-                    deps.add(dep);
-                }
-            }
-        }
-    }
-    return [...deps];
-}
-/**
- * Extract code blocks from markdown.
- * Only matches fences at column 0 (start of line) to avoid treating
- * indented code examples inside YAML plan fields as separate blocks.
- */
-export function extractCodeBlocks(markdown) {
-    const blocks = [];
-    // H1: Normalize CRLF to LF for cross-platform compatibility
-    const normalized = markdown.replace(/\r\n/g, '\n');
-    // Anchor opening and closing fences to start of line with multiline flag.
-    // This prevents indented ``` inside plan fields from being treated as delimiters.
-    const pattern = /^```(\w+)?[ \t]*\n(?:\/\/\s*(\S+)\n)?([\s\S]*?)^```[ \t]*$/gm;
-    let match;
-    while ((match = pattern.exec(normalized)) !== null) {
-        blocks.push({
-            language: match[1] || 'text',
-            filename: match[2],
-            code: match[3].trim(),
-        });
-    }
-    return blocks;
-}
-/**
- * Parse markdown into hierarchical sections.
- */
-export function parseMarkdownSections(markdown) {
-    const lines = markdown.split('\n');
-    const sections = [];
-    const stack = [];
-    let currentContent = [];
-    let inCodeBlock = false;
-    for (const line of lines) {
-        // Track code blocks to avoid parsing headers inside them
-        if (line.startsWith('```')) {
-            inCodeBlock = !inCodeBlock;
-            currentContent.push(line);
-            continue;
-        }
-        if (inCodeBlock) {
-            currentContent.push(line);
-            continue;
-        }
-        const headerMatch = line.match(/^(#{1,6})\s+(.+)$/);
-        if (headerMatch) {
-            // Save previous content
-            if (stack.length > 0) {
-                stack[stack.length - 1].content = currentContent.join('\n').trim();
-            }
-            currentContent = [];
-            const level = headerMatch[1].length;
-            const title = headerMatch[2].trim();
-            const section = {
-                level,
-                title,
-                content: '',
-                codeBlocks: [],
-                fileReferences: [],
-                explicitDeps: [],
-                children: [],
-            };
-            // Pop stack until we find a parent with lower level
-            while (stack.length > 0 && stack[stack.length - 1].level >= level) {
-                stack.pop();
-            }
-            if (stack.length > 0) {
-                stack[stack.length - 1].children.push(section);
-            }
-            else {
-                sections.push(section);
-            }
-            stack.push(section);
-        }
-        else {
-            currentContent.push(line);
-        }
-    }
-    // Save final content
-    if (stack.length > 0) {
-        stack[stack.length - 1].content = currentContent.join('\n').trim();
-    }
-    // Post-process sections to extract metadata
-    function processSection(section) {
-        section.codeBlocks = extractCodeBlocks(section.content);
-        section.fileReferences = extractFileReferences(section.content);
-        section.explicitDeps = extractExplicitDeps(section.content);
-        for (const child of section.children) {
-            processSection(child);
-        }
-    }
-    for (const section of sections) {
-        processSection(section);
-    }
-    return sections;
-}
-/**
- * Parse a markdown planning document.
- */
-export function parsePlanDocument(markdown) {
-    const sections = parseMarkdownSections(markdown);
-    // Extract title from first H1
-    const title = sections.find(s => s.level === 1)?.title ?? 'Untitled Plan';
-    // Extract description from content before first H2
-    const firstH1 = sections.find(s => s.level === 1);
-    const description = firstH1?.content.split('\n').slice(0, 3).join('\n') ?? '';
-    // Collect all file references and code blocks
-    const allFileReferences = new Set();
-    const allCodeBlocks = [];
-    function collectFromSection(section) {
-        for (const ref of section.fileReferences) {
-            allFileReferences.add(ref);
-        }
-        allCodeBlocks.push(...section.codeBlocks);
-        for (const child of section.children) {
-            collectFromSection(child);
-        }
-    }
-    for (const section of sections) {
-        collectFromSection(section);
-    }
-    return {
-        title,
-        description,
-        sections,
-        allFileReferences: [...allFileReferences],
-        allCodeBlocks,
-    };
-}
-/**
- * Get sections at a specific level (typically H2 for major deliverables).
- */
-export function getSectionsAtLevel(sections, level) {
-    const result = [];
-    function collect(section) {
-        if (section.level === level) {
-            result.push(section);
-        }
-        for (const child of section.children) {
-            collect(child);
-        }
-    }
-    for (const section of sections) {
-        collect(section);
-    }
-    return result;
-}
-/**
- * Flatten all sections into a single array.
- */
-export function flattenSections(sections) {
-    const result = [];
-    function collect(section) {
-        result.push(section);
-        for (const child of section.children) {
-            collect(child);
-        }
-    }
-    for (const section of sections) {
-        collect(section);
-    }
-    return result;
-}
-/**
- * Strip YAML-style trailing comments from a value.
- * A comment starts with ` #` (space + hash) followed by space or end-of-string.
- * Quoted strings (single or double) are preserved entirely.
- */
-function stripYamlComment(value) {
-    const trimmed = value.trim();
-    // Quoted strings: preserve entirely (comment is inside quotes)
-    if ((trimmed.startsWith('"') && trimmed.endsWith('"')) ||
-        (trimmed.startsWith("'") && trimmed.endsWith("'"))) {
-        return trimmed;
-    }
-    // Strip trailing comment: space(s) + # + (space or end)
-    return trimmed.replace(/\s+#(?=\s|$).*/, '').trim();
-}
-/**
- * Parse a simple YAML string into key-value pairs.
- * Handles basic YAML with string values, arrays, and multi-line strings.
- */
-function parseSimpleYaml(yaml) {
-    const result = {};
-    const lines = yaml.split('\n');
-    let currentKey = null;
-    let currentValue = [];
-    let inMultiLine = false;
-    let inArray = false;
-    let arrayItems = [];
-    for (const line of lines) {
-        // Multi-line string continuation (indented under |)
-        if (inMultiLine && (line.startsWith('  ') || line.startsWith('\t') || line.trim() === '')) {
-            currentValue.push(line.replace(/^  /, '').replace(/^\t/, ''));
-            continue;
-        }
-        else if (inMultiLine) {
-            // End of multi-line, save and reset
-            if (currentKey) {
-                result[currentKey] = currentValue.join('\n').trim();
-            }
-            inMultiLine = false;
-            currentKey = null;
-            currentValue = [];
-        }
-        // Array item (- value)
-        if (inArray && line.match(/^\s+-\s+/)) {
-            const item = line.replace(/^\s+-\s+/, '').trim();
-            arrayItems.push(stripYamlComment(item));
-            continue;
-        }
-        else if (inArray && !line.match(/^\s+-\s+/) && line.trim() !== '') {
-            // End of array, save and reset
-            if (currentKey) {
-                result[currentKey] = arrayItems;
-            }
-            inArray = false;
-            currentKey = null;
-            arrayItems = [];
-        }
-        // Key-value pair
-        const kvMatch = line.match(/^([\w-]+):\s*(.*)$/);
-        if (kvMatch) {
-            const [, key, value] = kvMatch;
-            // Inline array: [a, b, c]
-            if (value.startsWith('[') && value.endsWith(']')) {
-                const items = value.slice(1, -1).split(',').map(s => stripYamlComment(s).replace(/['"]/g, ''));
-                result[key] = items.filter(i => i.length > 0);
-                continue;
-            }
-            // Multi-line string starts with |
-            if (value === '|' || value === '|-') {
-                currentKey = key;
-                currentValue = [];
-                inMultiLine = true;
-                continue;
-            }
-            // Array starts on next line
-            if (value === '') {
-                currentKey = key;
-                arrayItems = [];
-                inArray = true;
-                continue;
-            }
-            // Simple string value
-            result[key] = stripYamlComment(value).replace(/^["']|["']$/g, '');
-        }
-    }
-    // Handle final multi-line or array
-    if (inMultiLine && currentKey) {
-        result[currentKey] = currentValue.join('\n').trim();
-    }
-    if (inArray && currentKey) {
-        result[currentKey] = arrayItems;
-    }
-    return result;
-}
-/**
- * Extract individual stream blocks from a nested `streams:` YAML structure.
- * Handles the common pattern where multiple streams are defined under a single wrapper:
- *
- *   streams:
- *     stream-id:
- *       name: "..."
- *       owns: [...]
- */
-function extractNestedStreamBlocks(yaml) {
-    const lines = yaml.split('\n');
-    const blocks = [];
-    // Must start with `streams:` top-level key
-    const streamsLineIdx = lines.findIndex(l => /^streams:\s*$/.test(l));
-    if (streamsLineIdx === -1)
-        return [];
-    let currentId = null;
-    let currentLines = [];
-    for (let i = streamsLineIdx + 1; i < lines.length; i++) {
-        const line = lines[i];
-        // Stream ID line: exactly 2-space indent, key with alphanumeric/hyphens/underscores, ends with :
-        const streamIdMatch = line.match(/^  ([\w-]+):\s*$/);
-        if (streamIdMatch) {
-            // Save previous stream (H2: skip empty streams)
-            if (currentId && currentLines.some(l => l.trim())) {
-                blocks.push({ id: currentId, block: currentLines.join('\n') });
-            }
-            currentId = streamIdMatch[1];
-            currentLines = [];
-            continue;
-        }
-        // Lines belonging to current stream (4+ spaces indent) or blank lines
-        if (currentId && (/^    /.test(line) || line.trim() === '')) {
-            // Strip 4 spaces of indentation to make it parseable as flat YAML
-            currentLines.push(line.replace(/^    /, ''));
-            continue;
-        }
-        // Non-indented non-empty line — we've left the streams: block
-        if (line.trim() !== '' && !/^\s/.test(line)) {
-            break;
-        }
-    }
-    // Save last stream (H2: skip empty streams)
-    if (currentId && currentLines.some(l => l.trim())) {
-        blocks.push({ id: currentId, block: currentLines.join('\n') });
-    }
-    return blocks;
-}
-/**
- * Parse a flat YAML block into a YamlStreamDefinition, applying optional id override.
- */
-function parseFlatYamlDef(yaml, idOverride) {
-    const parsed = parseSimpleYaml(yaml);
-    const id = idOverride ?? parsed.id ?? '';
-    const name = parsed.name ?? '';
-    // Must have at least id or name
-    if (!id && !name) {
-        logger.warn({ block: yaml.slice(0, 100) }, 'Malformed YAML block skipped — no id or name found');
-        return undefined;
-    }
-    const def = { id, name };
-    if (parsed.deps) {
-        def.deps = Array.isArray(parsed.deps) ? parsed.deps : [parsed.deps];
-    }
-    if (parsed.owns) {
-        def.owns = Array.isArray(parsed.owns) ? parsed.owns : [parsed.owns];
-    }
-    if (parsed.reads) {
-        def.reads = Array.isArray(parsed.reads) ? parsed.reads : [parsed.reads];
-    }
-    if (parsed.plan) {
-        def.plan = parsed.plan;
-    }
-    if (parsed.verify) {
-        def.verify = Array.isArray(parsed.verify) ? parsed.verify : [parsed.verify];
-    }
-    if (parsed.setup) {
-        def.setup = Array.isArray(parsed.setup) ? parsed.setup : [parsed.setup];
-    }
-    return def;
-}
-/**
- * Extract YAML stream definitions from code blocks in a section.
- * Supports both flat format (one block per stream) and nested `streams:` wrapper format.
- */
-export function extractYamlStreamDefinitions(section) {
-    const definitions = [];
-    for (const block of section.codeBlocks) {
-        if (block.language !== 'yaml' && block.language !== 'yml') {
-            continue;
-        }
-        // Try nested streams: wrapper format first
-        const nestedBlocks = extractNestedStreamBlocks(block.code);
-        if (nestedBlocks.length > 0) {
-            for (const { id, block: streamBlock } of nestedBlocks) {
-                const def = parseFlatYamlDef(streamBlock, id);
-                if (def)
-                    definitions.push(def);
-            }
-            continue;
-        }
-        // Fall back to flat format (id: at top level)
-        if (!block.code.includes('id:') && !block.code.includes('name:')) {
-            continue;
-        }
-        const def = parseFlatYamlDef(block.code);
-        if (def)
-            definitions.push(def);
-    }
-    return definitions;
-}
-/**
- * Find all sections that contain YAML stream definitions.
- */
-export function findYamlStreamSections(sections) {
-    const result = [];
-    function collect(section) {
-        const defs = extractYamlStreamDefinitions(section);
-        if (defs.length > 0) {
-            result.push(section);
-        }
-        for (const child of section.children) {
-            collect(child);
-        }
-    }
-    for (const section of sections) {
-        collect(section);
-    }
-    return result;
-}
-/**
- * Detect whether content is an unpopulated init-plan template.
- * Checks for the ORCHEX PLAN TEMPLATE marker in HTML comments.
- */
-export function isUnpopulatedTemplate(content) {
-    return content.includes('ORCHEX PLAN TEMPLATE');
-}

package/dist/intelligence/planner.d.ts

@@ -1,29 +0,0 @@
-import type { StreamDefinition } from '../types.js';
-import type { PatternAnalysis } from './pattern-analyzer.js';
-import { type ContextOptimization } from './context-optimizer.js';
-export interface StreamSuggestion {
-    id: string;
-    stream: Omit<StreamDefinition, 'status' | 'attempts' | 'error'>;
-    complexity: {
-        score: number;
-        factors: string[];
-    };
-    confidence: 'high' | 'medium' | 'low';
-}
-export interface PlanSuggestion {
-    suggestions: StreamSuggestion[];
-    waveEstimate: number;
-    notes: string[];
-    contextOptimization?: ContextOptimization;
-    retryGuidance?: PatternAnalysis;
-}
-/**
- * Suggest streams from a feature description and project file contents.
- * This is advisory — the user/AI reviews before accepting.
- */
-export declare function suggestStreams(featureDescription: string, fileContents: Record<string, string>): PlanSuggestion;
-/**
- * Enhance plan suggestion with pattern analysis and context optimization.
- * Requires telemetry data for pattern analysis.
- */
-export declare function enhancePlanSuggestion(plan: PlanSuggestion, fileContents: Record<string, string>, patterns?: PatternAnalysis): PlanSuggestion;

package/dist/intelligence/planner.js

@@ -1,86 +0,0 @@
-import { detectFileCoChanges, estimateComplexity } from './heuristics.js';
-import { optimizeContext } from './context-optimizer.js';
-/**
- * Suggest streams from a feature description and project file contents.
- * This is advisory — the user/AI reviews before accepting.
- */
-export function suggestStreams(featureDescription, fileContents) {
-    const suggestions = [];
-    const notes = [];
-    // 1. Detect file groups from co-change analysis
-    const groups = detectFileCoChanges(fileContents);
-    if (groups.length > 0) {
-        notes.push(`Found ${groups.length} tightly coupled file group(s) — consider grouping in same stream.`);
-    }
-    // 2. Identify test files that likely need updating
-    const testFiles = Object.keys(fileContents).filter((f) => f.includes('.test.') || f.includes('.spec.') || f.startsWith('tests/'));
-    const sourceFiles = Object.keys(fileContents).filter((f) => !testFiles.includes(f) && (f.endsWith('.ts') || f.endsWith('.js')));
-    // 3. Generate stream suggestions per file group
-    for (const group of groups) {
-        const id = group.files[0]
-            .replace(/^src\//, '')
-            .replace(/\.ts$/, '')
-            .replace(/\//g, '-');
-        const streamDef = {
-            name: `Update ${group.files.join(', ')}`,
-            owns: group.files,
-            reads: [],
-            deps: [],
-            plan: `Modify tightly coupled files: ${group.files.join(', ')}. ${group.reason}`,
-            setup: [],
-            verify: ['npm test'],
-        };
-        const complexity = estimateComplexity(streamDef);
-        suggestions.push({
-            id,
-            stream: streamDef,
-            complexity,
-            confidence: 'medium',
-        });
-    }
-    // 4. Suggest a test stream if test files exist
-    if (testFiles.length > 0) {
-        const testStream = {
-            name: 'Update tests',
-            owns: testFiles,
-            reads: sourceFiles.slice(0, 5), // read at most 5 source files for context
-            deps: suggestions.map((s) => s.id),
-            plan: `Update tests after source changes. Test files: ${testFiles.join(', ')}`,
-            setup: [],
-            verify: ['npm test'],
-        };
-        suggestions.push({
-            id: 'update-tests',
-            stream: testStream,
-            complexity: estimateComplexity(testStream),
-            confidence: 'low',
-        });
-    }
-    // 5. Estimate waves
-    const waveEstimate = Math.max(1, suggestions.filter((s) => s.stream.deps?.length === 0).length > 0 ? 2 : 1);
-    return { suggestions, waveEstimate, notes };
-}
-/**
- * Enhance plan suggestion with pattern analysis and context optimization.
- * Requires telemetry data for pattern analysis.
- */
-export function enhancePlanSuggestion(plan, fileContents, patterns) {
-    // Add context optimization for each stream
-    for (const suggestion of plan.suggestions) {
-        const optimization = optimizeContext(suggestion.stream.owns ?? [], suggestion.stream.reads ?? [], fileContents, suggestion.stream.deps?.length ?? 0);
-        if (optimization.estimatedSavings > 10) {
-            plan.notes.push(`Stream "${suggestion.id}": Context optimization could save ~${optimization.estimatedSavings}% tokens by pruning ${optimization.excludedFiles.length} unused files.`);
-        }
-    }
-    // Add retry guidance from patterns
-    if (patterns && patterns.retryPatterns.length > 0) {
-        plan.retryGuidance = patterns;
-        const highRetryCategories = patterns.retryPatterns
-            .filter(p => p.recommendation === 'always_retry')
-            .map(p => p.category);
-        if (highRetryCategories.length > 0) {
-            plan.notes.push(`Retry recommendation: Always retry for ${highRetryCategories.join(', ')} errors (high success rate).`);
-        }
-    }
-    return plan;
-}

package/dist/intelligence/self-healer.d.ts

@@ -1,16 +0,0 @@
-import type { StreamDefinition, Manifest } from '../types.js';
-export interface FixStreamResult {
-    fixStreamId: string;
-    fixStream: StreamDefinition;
-    analysis: {
-        category: string;
-        suggestion: string;
-    };
-}
-/**
- * Generate a fix stream for a failed stream.
- * Returns null if the error is non-retryable or max attempts exceeded.
- *
- * Tracks fix chain depth via parentStreamId to prevent infinite fix-fix-fix chains.
- */
-export declare function generateFixStream(manifest: Manifest, failedStreamId: string): FixStreamResult | null;