openlore 2.0.0

package/dist/core/generator/openspec-compat.d.ts

@@ -0,0 +1,160 @@
+/**
+ * OpenSpec Compatibility Layer
+ *
+ * Ensures perfect compatibility with OpenSpec's tooling and conventions.
+ * Handles config.yaml integration, validation, and context injection.
+ */
+import type { ProjectSurveyResult } from './spec-pipeline.js';
+/**
+ * Validation result for specs and config
+ */
+export interface ValidationResult {
+    valid: boolean;
+    errors: string[];
+    warnings: string[];
+}
+/**
+ * OpenSpec config.yaml structure
+ */
+export interface OpenSpecConfig {
+    schema?: string;
+    context?: string;
+    rules?: {
+        proposal?: string[];
+        specs?: string[];
+        design?: string[];
+        tasks?: string[];
+    };
+    'openlore'?: OpenLoreMetadata;
+}
+/**
+ * openlore metadata added to config.yaml
+ */
+export interface OpenLoreMetadata {
+    version: string;
+    generatedAt: string;
+    domains: string[];
+    confidence: number;
+    adrCount?: number;
+}
+/**
+ * Detected project context for injection
+ */
+export interface DetectedContext {
+    techStack: string;
+    architecture: string;
+    domains: string[];
+    patterns: string[];
+}
+/**
+ * Options for context update
+ */
+export interface ContextUpdateOptions {
+    preserveUserContext: boolean;
+    appendDetectedInfo: boolean;
+    version: string;
+}
+/**
+ * OpenSpec validator for specs and configuration
+ */
+export declare class OpenSpecValidator {
+    /**
+     * Validate the complete spec structure
+     */
+    validateSpecStructure(content: string): ValidationResult;
+    /**
+     * Validate requirement format follows RFC 2119
+     */
+    validateRequirementFormat(requirement: string): ValidationResult;
+    /**
+     * Validate scenario format (Given/When/Then)
+     */
+    validateScenarioFormat(scenario: string): ValidationResult;
+    /**
+     * Validate config.yaml structure
+     */
+    validateConfigYaml(config: unknown): ValidationResult;
+    /**
+     * Check heading hierarchy is valid (no skipped levels)
+     */
+    private checkHeadingHierarchy;
+    /**
+     * Check for malformed markdown links
+     */
+    private checkMarkdownLinks;
+}
+/**
+ * OpenSpec config.yaml manager
+ */
+export declare class OpenSpecConfigManager {
+    private configPath;
+    private openspecRoot;
+    constructor(projectRoot: string);
+    /**
+     * Check if OpenSpec is initialized
+     */
+    isInitialized(): Promise<boolean>;
+    /**
+     * Check if config.yaml exists
+     */
+    hasConfig(): Promise<boolean>;
+    /**
+     * Read existing config.yaml
+     */
+    readConfig(): Promise<OpenSpecConfig | null>;
+    /**
+     * Write config.yaml, preserving user content
+     */
+    writeConfig(config: OpenSpecConfig): Promise<void>;
+    /**
+     * Update config with openlore metadata while preserving user content
+     */
+    updateWithOpenLoreMetadata(metadata: OpenLoreMetadata, detectedContext?: DetectedContext, options?: ContextUpdateOptions): Promise<OpenSpecConfig>;
+    /**
+     * Build context string combining user and detected info
+     */
+    private buildContext;
+    /**
+     * Get existing user context from config
+     */
+    getUserContext(): Promise<string | null>;
+    /**
+     * Get existing domains from specs directory
+     */
+    getExistingDomains(): Promise<string[]>;
+}
+/**
+ * Build detected context from analysis results
+ */
+export declare function buildDetectedContext(survey: ProjectSurveyResult): DetectedContext;
+/**
+ * Normalize domain name to OpenSpec conventions
+ */
+export declare function normalizeDomainName(name: string): string;
+/**
+ * Check if domain name follows conventions
+ */
+export declare function isValidDomainName(name: string): boolean;
+/**
+ * Match suggested domains against existing domains
+ */
+export declare function matchExistingDomains(suggestedDomains: string[], existingDomains: string[]): Map<string, string>;
+/**
+ * Validate a complete spec file
+ */
+export declare function validateFullSpec(content: string): ValidationResult;
+/**
+ * Validate all specs in a directory
+ */
+export declare function validateSpecsDirectory(specsDir: string): Promise<{
+    valid: boolean;
+    results: Map<string, ValidationResult>;
+}>;
+/**
+ * Create a new OpenSpec compatibility helper
+ */
+export declare function createOpenSpecCompat(projectRoot: string): {
+    validator: OpenSpecValidator;
+    configManager: OpenSpecConfigManager;
+};
+//# sourceMappingURL=openspec-compat.d.ts.map

package/dist/core/generator/openspec-compat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openspec-compat.d.ts","sourceRoot":"","sources":["../../../src/core/generator/openspec-compat.ts"],"names":[],"mappings":"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"}

package/dist/core/generator/openspec-compat.js

@@ -0,0 +1,524 @@
+/**
+ * OpenSpec Compatibility Layer
+ *
+ * Ensures perfect compatibility with OpenSpec's tooling and conventions.
+ * Handles config.yaml integration, validation, and context injection.
+ */
+import { readFile, writeFile, mkdir, access, readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { parse as parseYaml, stringify as stringifyYaml } from 'yaml';
+import logger from '../../utils/logger.js';
+import { OPENSPEC_DIR, OPENSPEC_CONFIG_FILENAME } from '../../constants.js';
+// ============================================================================
+// OPENSPEC VALIDATION
+// ============================================================================
+/**
+ * OpenSpec validator for specs and configuration
+ */
+export class OpenSpecValidator {
+    /**
+     * Validate the complete spec structure
+     */
+    validateSpecStructure(content) {
+        const errors = [];
+        const warnings = [];
+        // Check for title (# heading at start)
+        if (!content.match(/^#\s+.+/m)) {
+            errors.push('Missing title (# heading)');
+        }
+        // Check for Purpose section
+        if (!content.includes('## Purpose')) {
+            warnings.push('Missing Purpose section (recommended)');
+        }
+        // Check for Requirements section (except overview which may have Domains instead)
+        if (!content.includes('## Requirements') && !content.includes('## Domains') && !content.includes('## Key Capabilities')) {
+            warnings.push('Missing Requirements section');
+        }
+        // Check for delta markers (should not be in generated specs)
+        if (content.match(/\[ADDED\]|\[MODIFIED\]|\[REMOVED\]/)) {
+            errors.push('Generated specs should not contain delta markers ([ADDED], [MODIFIED], [REMOVED])');
+        }
+        // Check markdown structure is valid
+        const headingLevels = this.checkHeadingHierarchy(content);
+        if (!headingLevels.valid) {
+            warnings.push(...headingLevels.issues);
+        }
+        // Check for broken links
+        const brokenLinks = this.checkMarkdownLinks(content);
+        if (brokenLinks.length > 0) {
+            warnings.push(...brokenLinks.map(link => `Potentially malformed link: ${link}`));
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+            warnings,
+        };
+    }
+    /**
+     * Validate requirement format follows RFC 2119
+     */
+    validateRequirementFormat(requirement) {
+        const errors = [];
+        const warnings = [];
+        // Check for RFC 2119 keywords
+        const rfc2119Keywords = /\b(SHALL|MUST|SHOULD|MAY|SHALL NOT|MUST NOT|SHOULD NOT|MAY NOT)\b/;
+        if (!rfc2119Keywords.test(requirement)) {
+            warnings.push('Requirement does not use RFC 2119 keywords (SHALL, MUST, SHOULD, MAY)');
+        }
+        // Check for imperative form
+        if (requirement.match(/^The system\s+/i) === null && requirement.match(/^The\s+\w+\s+(SHALL|MUST|SHOULD|MAY)/i) === null) {
+            warnings.push('Requirement should start with "The system" or "The [component]"');
+        }
+        // Check it's not too short (likely incomplete)
+        if (requirement.split(/\s+/).length < 5) {
+            warnings.push('Requirement may be too brief');
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+            warnings,
+        };
+    }
+    /**
+     * Validate scenario format (Given/When/Then)
+     */
+    validateScenarioFormat(scenario) {
+        const errors = [];
+        const warnings = [];
+        // Check for scenario heading with exactly 4 hashtags
+        if (!scenario.match(/^####\s+Scenario:/m)) {
+            errors.push('Scenario heading must use exactly 4 hashtags (####)');
+        }
+        // Check for GIVEN
+        if (!scenario.includes('**GIVEN**') && !scenario.includes('- **GIVEN**')) {
+            errors.push('Scenario missing GIVEN clause');
+        }
+        // Check for WHEN
+        if (!scenario.includes('**WHEN**') && !scenario.includes('- **WHEN**')) {
+            errors.push('Scenario missing WHEN clause');
+        }
+        // Check for THEN
+        if (!scenario.includes('**THEN**') && !scenario.includes('- **THEN**')) {
+            errors.push('Scenario missing THEN clause');
+        }
+        // AND is optional but if present should be formatted correctly
+        if (scenario.includes('AND') && !scenario.match(/\*\*AND\*\*/)) {
+            warnings.push('AND clause should be bolded (**AND**)');
+        }
+        // Check order: GIVEN should come before WHEN, WHEN before THEN
+        const givenIndex = scenario.indexOf('**GIVEN**');
+        const whenIndex = scenario.indexOf('**WHEN**');
+        const thenIndex = scenario.indexOf('**THEN**');
+        if (givenIndex !== -1 && whenIndex !== -1 && givenIndex > whenIndex) {
+            errors.push('GIVEN must come before WHEN');
+        }
+        if (whenIndex !== -1 && thenIndex !== -1 && whenIndex > thenIndex) {
+            errors.push('WHEN must come before THEN');
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+            warnings,
+        };
+    }
+    /**
+     * Validate config.yaml structure
+     */
+    validateConfigYaml(config) {
+        const errors = [];
+        const warnings = [];
+        if (typeof config !== 'object' || config === null) {
+            errors.push('Config must be an object');
+            return { valid: false, errors, warnings };
+        }
+        const configObj = config;
+        // Check schema field
+        if (configObj.schema !== undefined && typeof configObj.schema !== 'string') {
+            errors.push('schema must be a string');
+        }
+        // Check context field
+        if (configObj.context !== undefined && typeof configObj.context !== 'string') {
+            errors.push('context must be a string');
+        }
+        // Check rules field
+        if (configObj.rules !== undefined) {
+            if (typeof configObj.rules !== 'object' || configObj.rules === null) {
+                errors.push('rules must be an object');
+            }
+            else {
+                const rules = configObj.rules;
+                const allowedRuleKeys = ['proposal', 'specs', 'design', 'tasks'];
+                for (const key of Object.keys(rules)) {
+                    if (!allowedRuleKeys.includes(key)) {
+                        warnings.push(`Unknown rule key: ${key}`);
+                    }
+                    if (!Array.isArray(rules[key])) {
+                        errors.push(`rules.${key} must be an array`);
+                    }
+                }
+            }
+        }
+        // Check openlore metadata if present
+        if (configObj['openlore'] !== undefined) {
+            const openlore = configObj['openlore'];
+            if (typeof openlore.version !== 'string') {
+                warnings.push('openlore.version should be a string');
+            }
+            if (typeof openlore.generatedAt !== 'string') {
+                warnings.push('openlore.generatedAt should be a string');
+            }
+            if (!Array.isArray(openlore.domains)) {
+                warnings.push('openlore.domains should be an array');
+            }
+            if (typeof openlore.confidence !== 'number') {
+                warnings.push('openlore.confidence should be a number');
+            }
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+            warnings,
+        };
+    }
+    /**
+     * Check heading hierarchy is valid (no skipped levels)
+     */
+    checkHeadingHierarchy(content) {
+        const issues = [];
+        const headings = content.match(/^#{1,6}\s+.+/gm) || [];
+        let lastLevel = 0;
+        for (const heading of headings) {
+            const match = heading.match(/^(#{1,6})/);
+            if (match) {
+                const level = match[1].length;
+                if (level > lastLevel + 1 && lastLevel !== 0) {
+                    issues.push(`Heading level jumped from ${lastLevel} to ${level}: "${heading.slice(0, 50)}..."`);
+                }
+                lastLevel = level;
+            }
+        }
+        return { valid: issues.length === 0, issues };
+    }
+    /**
+     * Check for malformed markdown links
+     */
+    checkMarkdownLinks(content) {
+        const malformed = [];
+        // Find all markdown links
+        const linkPattern = /\[([^\]]*)\]\(([^)]*)\)/g;
+        let match;
+        while ((match = linkPattern.exec(content)) !== null) {
+            const [fullMatch, text, url] = match;
+            // Check for empty text or URL
+            if (!text.trim()) {
+                malformed.push(fullMatch);
+            }
+            if (!url.trim()) {
+                malformed.push(fullMatch);
+            }
+            // Check for obviously broken URLs
+            if (url.includes(' ') && !url.startsWith('http')) {
+                malformed.push(fullMatch);
+            }
+        }
+        return malformed;
+    }
+}
+// ============================================================================
+// CONFIG.YAML MANAGER
+// ============================================================================
+/**
+ * OpenSpec config.yaml manager
+ */
+export class OpenSpecConfigManager {
+    configPath;
+    openspecRoot;
+    constructor(projectRoot) {
+        this.openspecRoot = join(projectRoot, OPENSPEC_DIR);
+        this.configPath = join(this.openspecRoot, OPENSPEC_CONFIG_FILENAME);
+    }
+    /**
+     * Check if OpenSpec is initialized
+     */
+    async isInitialized() {
+        try {
+            await access(this.openspecRoot);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Check if config.yaml exists
+     */
+    async hasConfig() {
+        try {
+            await access(this.configPath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Read existing config.yaml
+     */
+    async readConfig() {
+        try {
+            const content = await readFile(this.configPath, 'utf-8');
+            return parseYaml(content);
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Write config.yaml, preserving user content
+     */
+    async writeConfig(config) {
+        await mkdir(this.openspecRoot, { recursive: true });
+        const content = stringifyYaml(config, { lineWidth: 100 });
+        await writeFile(this.configPath, content, 'utf-8');
+        logger.success(`Updated ${this.configPath}`);
+    }
+    /**
+     * Update config with openlore metadata while preserving user content
+     */
+    async updateWithOpenLoreMetadata(metadata, detectedContext, options = {
+        preserveUserContext: true,
+        appendDetectedInfo: true,
+        version: '1.0.0',
+    }) {
+        let config = await this.readConfig();
+        if (!config) {
+            config = {
+                schema: 'spec-driven',
+            };
+        }
+        // Add openlore metadata
+        config['openlore'] = metadata;
+        // Update context if we have detected info and user approves
+        if (detectedContext && options.appendDetectedInfo) {
+            config.context = this.buildContext(config.context, detectedContext, options.preserveUserContext);
+        }
+        await this.writeConfig(config);
+        return config;
+    }
+    /**
+     * Build context string combining user and detected info
+     */
+    buildContext(existingContext, detected, preserveUser) {
+        const lines = [];
+        // Preserve user context if it exists
+        if (preserveUser && existingContext) {
+            lines.push('# User-provided context (preserved)');
+            lines.push(existingContext.trim());
+            lines.push('');
+        }
+        // Add auto-detected context
+        lines.push('# Auto-detected by openlore');
+        lines.push(`Tech stack: ${detected.techStack}`);
+        lines.push(`Architecture: ${detected.architecture}`);
+        lines.push(`Domains: ${detected.domains.join(', ')}`);
+        if (detected.patterns.length > 0) {
+            lines.push(`Key patterns: ${detected.patterns.join(', ')}`);
+        }
+        return lines.join('\n');
+    }
+    /**
+     * Get existing user context from config
+     */
+    async getUserContext() {
+        const config = await this.readConfig();
+        return config?.context ?? null;
+    }
+    /**
+     * Get existing domains from specs directory
+     */
+    async getExistingDomains() {
+        const specsDir = join(this.openspecRoot, 'specs');
+        try {
+            const entries = await readdir(specsDir, { withFileTypes: true });
+            return entries
+                .filter(e => e.isDirectory())
+                .map(e => e.name)
+                .filter(name => !['overview', 'architecture', 'api'].includes(name));
+        }
+        catch {
+            return [];
+        }
+    }
+}
+// ============================================================================
+// CONTEXT INJECTION
+// ============================================================================
+/**
+ * Build detected context from analysis results
+ */
+export function buildDetectedContext(survey) {
+    // Build tech stack description
+    const techStack = [survey.primaryLanguage, ...survey.frameworks].join(', ');
+    // Build architecture description
+    const archPatterns = {
+        layered: 'Layered (routes → controllers → services → repositories)',
+        hexagonal: 'Hexagonal/Ports & Adapters',
+        microservices: 'Microservices',
+        monolith: 'Monolithic',
+        serverless: 'Serverless',
+        'event-driven': 'Event-Driven',
+        mvc: 'Model-View-Controller',
+        other: 'Custom architecture',
+    };
+    const architecture = archPatterns[survey.architecturePattern] || survey.architecturePattern;
+    // Detect common patterns from frameworks
+    const patterns = [];
+    if (survey.frameworks.some(f => f.toLowerCase().includes('typeorm') || f.toLowerCase().includes('prisma'))) {
+        patterns.push('Repository pattern');
+    }
+    if (survey.frameworks.some(f => f.toLowerCase().includes('inversify') || f.toLowerCase().includes('tsyringe'))) {
+        patterns.push('Dependency injection');
+    }
+    if (survey.frameworks.some(f => f.toLowerCase().includes('express') || f.toLowerCase().includes('fastify'))) {
+        patterns.push('Middleware pipeline');
+    }
+    if (survey.frameworks.some(f => f.toLowerCase().includes('react') || f.toLowerCase().includes('vue'))) {
+        patterns.push('Component-based UI');
+    }
+    return {
+        techStack,
+        architecture,
+        domains: survey.suggestedDomains,
+        patterns,
+    };
+}
+// ============================================================================
+// DOMAIN NAMING
+// ============================================================================
+/**
+ * Normalize domain name to OpenSpec conventions
+ */
+export function normalizeDomainName(name) {
+    return name
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .replace(/--+/g, '-');
+}
+/**
+ * Check if domain name follows conventions
+ */
+export function isValidDomainName(name) {
+    // Must be lowercase kebab-case
+    if (!/^[a-z][a-z0-9-]*[a-z0-9]$/.test(name) && !/^[a-z]$/.test(name)) {
+        return false;
+    }
+    // Avoid generic names
+    const genericNames = ['misc', 'other', 'utils', 'common', 'shared', 'general', 'helpers'];
+    if (genericNames.includes(name)) {
+        return false;
+    }
+    return true;
+}
+/**
+ * Match suggested domains against existing domains
+ */
+export function matchExistingDomains(suggestedDomains, existingDomains) {
+    const matches = new Map();
+    for (const suggested of suggestedDomains) {
+        const normalized = normalizeDomainName(suggested);
+        // Exact match
+        if (existingDomains.includes(normalized)) {
+            matches.set(suggested, normalized);
+            continue;
+        }
+        // Partial match (suggested is substring or vice versa)
+        for (const existing of existingDomains) {
+            if (existing.includes(normalized) || normalized.includes(existing)) {
+                matches.set(suggested, existing);
+                break;
+            }
+        }
+    }
+    return matches;
+}
+// ============================================================================
+// FULL SPEC VALIDATION
+// ============================================================================
+/**
+ * Validate a complete spec file
+ */
+export function validateFullSpec(content) {
+    const validator = new OpenSpecValidator();
+    const result = validator.validateSpecStructure(content);
+    // Also validate all requirements in the spec
+    const requirementBlocks = content.match(/###\s+Requirement:[^\n]+[\s\S]*?(?=###\s+Requirement:|## |$)/g) || [];
+    for (const block of requirementBlocks) {
+        const reqResult = validator.validateRequirementFormat(block);
+        result.warnings.push(...reqResult.warnings);
+        result.errors.push(...reqResult.errors);
+    }
+    // Validate all scenarios
+    const scenarioBlocks = content.match(/####\s+Scenario:[^\n]+[\s\S]*?(?=####\s+Scenario:|###\s+Requirement:|## |$)/g) || [];
+    for (const block of scenarioBlocks) {
+        const scenResult = validator.validateScenarioFormat(block);
+        result.warnings.push(...scenResult.warnings);
+        result.errors.push(...scenResult.errors);
+    }
+    // Update valid status
+    result.valid = result.errors.length === 0;
+    return result;
+}
+/**
+ * Validate all specs in a directory
+ */
+export async function validateSpecsDirectory(specsDir) {
+    const results = new Map();
+    let allValid = true;
+    try {
+        const entries = await readdir(specsDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                const specPath = join(specsDir, entry.name, 'spec.md');
+                try {
+                    const content = await readFile(specPath, 'utf-8');
+                    const result = validateFullSpec(content);
+                    results.set(entry.name, result);
+                    if (!result.valid) {
+                        allValid = false;
+                    }
+                }
+                catch {
+                    // spec.md doesn't exist in this directory
+                    results.set(entry.name, {
+                        valid: false,
+                        errors: ['spec.md not found'],
+                        warnings: [],
+                    });
+                    allValid = false;
+                }
+            }
+        }
+    }
+    catch {
+        // specs directory doesn't exist
+        return {
+            valid: false,
+            results: new Map([['specs', { valid: false, errors: ['specs directory not found'], warnings: [] }]]),
+        };
+    }
+    return { valid: allValid, results };
+}
+// ============================================================================
+// CONVENIENCE EXPORTS
+// ============================================================================
+/**
+ * Create a new OpenSpec compatibility helper
+ */
+export function createOpenSpecCompat(projectRoot) {
+    return {
+        validator: new OpenSpecValidator(),
+        configManager: new OpenSpecConfigManager(projectRoot),
+    };
+}
+//# sourceMappingURL=openspec-compat.js.map